njs14/pkstack

Create polished, validated, offline-capable architecture, workflow, sequence, data-flow, and lifecycle diagrams with the reviewed Archify runtime.

Design or revise a component through grounded architecture analysis, structurally distinct alternatives, explicit tradeoffs, and executable verification. Use for system boundaries, APIs, data models, migrations, or high-impact refactors.

Compare multiple structurally distinct solutions to one artifact under a shared rubric, select a base, coherently graft the strongest ideas, and verify the result. Use when a design or implementation has meaningful competing approaches.

Turn a demonstrated, repeatable working style into a reviewable project-local Kiro skill without mining private transcripts or publishing changes automatically.

Check or supervise a GitHub pull request's CI, published review feedback, and mergeability; diagnose failures and repair authorized branch issues until the agreed stopping point.

Trace one proposed change or suspected defect through callers, state, boundaries, and executable behavior to establish its real blast radius.

Restate the prior answer in direct everyday language while preserving its important facts, caveats, and requested next action.

Build a bounded, observable, repo-local agent loop from locally runnable sensor, controller, Kiro actuator, validation, memory, and flow-control components.

Design and prove a project-local verification workflow that exercises real user behavior through a bounded, deterministic, rerunnable contract.

Design a locally runnable, observable agent control loop with an explicit set point, sensor, controller, Kiro actuator, disturbances, and dampener.

Reproduce and diagnose bugs or performance regressions with a tight feedback loop, competing hypotheses, and proof of the original symptom. Use when behavior fails, flakes, or becomes slow.

Resolve ambiguous project terminology and domain relationships against concrete scenarios and code, and maintain the resulting glossary and consequential decisions.

Solve an unfamiliar, ambiguous technical problem by turning it into bounded hypotheses, verifiable phases, and an auditable evidence trail.

Interview me to sharpen a plan, idea, or decision and expose consequential assumptions before I commit to it.

Interview me about a project plan or design and capture its reusable Wiki definitions, consequential decisions, and unresolved questions as the active workflow permits writes.

Supply PKStack planning and focused decision interviews with one evidence-grounded, dependency-ordered questioning method that stops when consequential choices are settled.

Write a focused resume document for a fresh session or another agent. Use when pausing work, transferring context, or resuming without repeating completed investigation.

Explain how a subsystem works from evidence, connecting entrypoints, data flow, state, boundaries, failure behavior, and verification seams.

Design, redesign, critique, audit, or refine a frontend interface, including its typography, layout, color, motion, responsive behavior, accessibility, and UX copy.

Survey selected modules or Git-history hotspots for architectural friction and present visual before/after candidates. Use to identify and choose a refactor before implementation.

Route a high-stakes proposal through the PKStack model council for evidence-bound challenge, without granting reviewers implementation authority.

Audit and update an existing verification workflow against current user-visible behavior while preserving scope, safety, and executable proof.

Narrow React component prop types to the states used by live application call sites, then adapt stories, tests, and mocks to the stricter contract.

Remove stale, redundant, or compensating code comments while preserving external contracts and the non-obvious reasons maintainers genuinely need.

Produce, maintain, or consume source-controlled Open Knowledge Format project knowledge through PKStack's bounded Kiro retrieval and local validation interfaces. Use when capturing durable architecture, decisions, concepts, operations, provenance, lifecycle, trust, or attested-computation guidance.

Advise which PKStack skill or Kiro workflow to use next in a new or existing project, and why. Use for project orientation, verification readiness, and workflow-choice questions; direct execution requests keep their existing owner.

Review one pinned upstream and adapt relevant changes into the PKStack Power. Use for requested or scheduled upstream maintenance.

Obtain independent reviews of the same change under one rubric, synthesize consensus and disagreement, and classify advice without auto-applying it. Use for high-risk decisions or when the user explicitly requests a model council, Fable review, or Grok review.

Select and apply one or more PKStack engineering principles to a design, implementation, debugging, review, or verification decision without importing runtime-specific upstream behavior.

Initialize or repair repository-local PKStack scaffolding for a Kiro workspace. Use when adopting PKStack, refreshing its feature-map and knowledge layout, or checking whether projectctl is ready.

Work toward a concrete objective in the current Kiro agent session and require deterministic projectctl verification before reporting success. Use for multi-step implementation, repair, migration, or refactoring with an executable acceptance check.

Route broad Poteto workflow requests into PKStack's Kiro-native skills, project interfaces, and current-session verification loop.

Question the shared assumption when two or more attempted fixes fail the same check; measure which actors hold the imbalance before proposing another fix.

Concentrate parsing, validation, and error translation at real system boundaries while keeping typed internal business logic small and direct.

Turn non-trivial repeated edits, migrations, analyses, or proof into the smallest safe rerunnable script, generator, check, or delegated-work contract.

Replace a recurring correction with the strongest practical type, lint, CI, helper, or runtime mechanism and prove the observed mistake now fails automatically.

Compare two or three structurally distinct designs for a novel interaction or architectural decision before committing to an implementation shape.

Resolve product, API, and workflow tradeoffs from the consuming user's experience, including failure and maintenance paths, rather than implementation convenience.

Reproduce a failure, trace the first incorrect value or state, fix that origin, and prove the nearby class of symptoms cannot return through another path.

Choose core data structures, state ownership, concurrency boundaries, and shared verification before dependent feature logic closes design options.

Bound large outputs and broad research, delegate independent slices when available, and retain only evidence that can change the next decision.

Prefer deletion and the smallest direct maintainable change when a refactor starts adding wrappers, layers, duplicated decisions, or signal threading.

Make commands, lifecycle steps, scheduled jobs, and retry loops converge safely after repeat runs and interruption at any write boundary.

When no external compatibility promise applies, inventory callers, migrate them to the chosen internal API, and remove the old path in the same bounded wave.

Reduce the layers a maintainer must trace and the mutable state they must remember while preserving boundaries that hide meaningful complexity.

Replace scattered state booleans, repeated shape assumptions, and branching with the smallest structure that encodes the real domain and its invariants.

Continue routine reversible in-scope work with visible assumptions while reserving questions for missing intent, new authority, or consequential actions.

Drive a planned migration or rewrite toward its explicit verifiable target without letting temporary compatibility become the permanent architecture.

Before declaring completion, exercise the real artifact and observable path with a deterministic check that would fail if the claim were false.

Integrate a cross-cutting requirement as if it had shaped the system from the start, then propagate one coherent rule through code, tests, docs, and examples.

Remove unnecessary shared write targets between concurrent actors before adding structural serialization for state that truly requires one writer.

Break multi-step work into small reversible units that each end in a meaningful check, then order delivery so the evidence identifies each causal change.

Remove dead paths, duplicate checks, stale references, and speculative surface area before adding or reshaping behavior in a complex area.

Write tests that invoke the real subject through its supported interface and assert an independently specified output or effect, rather than restating implementation details.

Use variants, constructive types, branded primitives, parsed boundaries, schema derivation, and exhaustive matching to make invalid typed states hard to express.

Recover relevant project context from the current Kiro session and explicit repository knowledge without silently mining unrelated private conversations.

When explicitly asked to reflect, extract durable lessons from completed work and propose the smallest structural, documentation, or skill improvement that would prevent repetition.

Investigate a bounded question against primary sources and produce a cited report. Use for documentation research, API guarantees, source comparisons, or delegated reading.

Resolve an in-progress Git merge or rebase by recovering both sides’ intent, preserving unrelated work, and verifying the integrated result.

Lint and format Python with Ruff using the project's configuration and pinned environment; review fixes against behavior and the requested scope.

Explain a topic visually with concise diagrams, code-shape sketches, or focused offline-capable HTML. Use for visual understanding rather than a decision-and-evidence log.

Produce a compact, auditable decision trail that connects requirements, evidence, choices, edits, and verification without exposing hidden reasoning.

Fan out bounded independent investigations or reviews across native Kiro sub-agents, then aggregate coverage, gaps, and evidence. Use for parallel research, repository inventory, test triage, or independent review tracks.

Implement a behavior change with a focused failing regression first, the smallest coherent fix, and layered executable evidence.

Teach a technical concept by connecting how it operates, why it was designed that way, and concrete examples without quizzing the user.

Write or revise technical documentation for a specific reader and task, with verified commands, direct language, and maintainable information placement.

Create a focused questionnaire for a person who holds missing knowledge. Use to obtain facts or decisions asynchronously while reusing known answers; creates the document without sending it.

Inspect issues and external PRs, verify claims, check duplicate or rejected requests, and prepare actionable briefs. Use for issue classification, triage queues, or readiness decisions.

Check Python types with ty, repair type errors at their source, and configure coverage for maintained modules and scripts without suppressing failures.

Design or review TypeScript with constructive domain types, boundary schemas, exhaustive variants, and tests that exercise runtime uncertainty.

Edit prose into concise, specific, human writing while preserving the author's facts, voice, uncertainty, and intended audience.

Manage Python projects, dependencies, environments, and standalone scripts with uv; preserve an existing Poetry or PDM workflow unless migration is requested.

Chart or resume a large, uncertain effort as a GitHub Cloud or Markdown map of decision tickets, retain reusable understanding in OKF, and hand the agreed direction to native Kiro planning.

Explain why a system or decision exists using code, tests, history, and documentation while separating direct evidence from plausible inference.

Generate a runnable guide for human-only setup or migration steps, with hidden secret entry and safe repeatable updates. Use when login, account UI, or human judgment prevents direct automation.

Write or revise agent-facing instructions, including AGENTS.md, Kiro Skills, steering files, and pointer-linked reference documents.