@jskit-ai/jskit-cli 0.2.89 → 0.2.91

package/src/server/sessionRuntime/io.js

@@ -10,7 +10,7 @@ function normalizeText(value) {
   return String(value || "").trim();
 }
 
-function timestampForReceipt(now = new Date()) {
+function timestampForStepRecord(now = new Date()) {
   return now.toISOString();
 }
 
@@ -92,6 +92,6 @@ export {
   runCommand,
   runGit,
   runGitInWorktree,
-  timestampForReceipt,
+  timestampForStepRecord,
   writeTextFile
 };

package/src/server/sessionRuntime/preconditions.js

@@ -271,7 +271,7 @@ async function assertDependenciesInstalled(paths) {
     error: createError({
       code: "dependencies_not_installed",
       message: "Cannot start issue work until dependencies are installed in the session worktree.",
-      repairCommand: jskitCommand(`session ${paths.sessionId} step`)
+      repairCommand: jskitCommand(`session ${paths.sessionId} run_npm_install`)
     }),
     precondition: createPrecondition({
       id: "dependencies_installed",
@@ -337,14 +337,16 @@ async function assertActiveCycleExists(paths) {
 
 async function assertActiveCycleUserCheckPassed(paths) {
   const activeCycle = await readTrimmedFile(path.join(paths.sessionRoot, "active_cycle"));
-  const receiptPath = path.join(paths.sessionRoot, "steps", `cycle_${activeCycle}`, "user_check_completed");
-  if (await pathExists(receiptPath)) {
+  if (
+    await pathExists(path.join(paths.sessionRoot, "steps", "user_check_completed")) ||
+    await pathExists(path.join(paths.sessionRoot, "steps", `cycle_${activeCycle || "001"}`, "user_check_completed"))
+  ) {
     return {
       ok: true,
       precondition: createPrecondition({
-        id: "active_cycle_user_check_passed",
+        id: "user_check_passed",
         ok: true,
-        message: "The active cycle user check has passed."
+        message: "The user check has passed."
       })
     };
   }
@@ -352,20 +354,24 @@ async function assertActiveCycleUserCheckPassed(paths) {
     ok: false,
     error: createError({
       code: "user_check_not_passed",
-      message: "Finalization cannot continue until the active cycle user check has passed.",
+      message: "Finalization cannot continue until the user check has passed.",
       repairCommand: jskitCommand(`session ${paths.sessionId} step --user-check passed`)
     }),
     precondition: createPrecondition({
-      id: "active_cycle_user_check_passed",
+      id: "user_check_passed",
       ok: false,
-      message: "The active cycle user check has passed."
+      message: "The user check has passed."
     })
   };
 }
 
+async function assertUserCheckPassed(paths) {
+  return assertActiveCycleUserCheckPassed(paths);
+}
+
 async function assertAcceptedChangesCommitted(paths) {
-  const receiptPath = path.join(paths.sessionRoot, "steps", "changes_committed");
-  if (await pathExists(receiptPath)) {
+  const recordPath = path.join(paths.sessionRoot, "steps", "changes_committed");
+  if (await pathExists(recordPath)) {
     return {
       ok: true,
       precondition: createPrecondition({
@@ -390,15 +396,17 @@ async function assertAcceptedChangesCommitted(paths) {
   };
 }
 
-async function assertActiveCycleStepReceipt(paths, {
+async function assertActiveCycleStepRecord(paths, {
   code,
   id,
   message,
   stepId
 }) {
   const activeCycle = await readTrimmedFile(path.join(paths.sessionRoot, "active_cycle"));
-  const receiptPath = path.join(paths.sessionRoot, "steps", `cycle_${activeCycle}`, stepId);
-  if (await pathExists(receiptPath)) {
+  if (
+    await pathExists(path.join(paths.sessionRoot, "steps", stepId)) ||
+    await pathExists(path.join(paths.sessionRoot, "steps", `cycle_${activeCycle || "001"}`, stepId))
+  ) {
     return {
       ok: true,
       precondition: createPrecondition({
@@ -424,16 +432,16 @@ async function assertActiveCycleStepReceipt(paths, {
 }
 
 async function assertAutomatedChecksPassed(paths) {
-  return assertActiveCycleStepReceipt(paths, {
+  return assertActiveCycleStepRecord(paths, {
     code: "automated_checks_not_passed",
     id: "automated_checks_passed",
-    message: "Automated checks have passed.",
+    message: "Run automated checks completed successfully.",
     stepId: "automated_checks_run"
   });
 }
 
 async function assertDeepUiCheckSatisfied(paths) {
-  return assertActiveCycleStepReceipt(paths, {
+  return assertActiveCycleStepRecord(paths, {
     code: "deep_ui_check_not_satisfied",
     id: "deep_ui_check_satisfied",
     message: "Deep UI check is satisfied.",
@@ -441,60 +449,6 @@ async function assertDeepUiCheckSatisfied(paths) {
   });
 }
 
-async function assertIssueMetadataExists(paths) {
-  const source = await readTextIfExists(path.join(paths.sessionRoot, "issue_metadata.json"));
-  if (!source) {
-    return {
-      ok: false,
-      error: createError({
-        code: "issue_metadata_missing",
-        message: "Cannot continue before issue_metadata.json records the issue category and UI impact.",
-        repairCommand: jskitCommand(`session ${paths.sessionId} step --issue-details -`)
-      }),
-      precondition: createPrecondition({
-        id: "issue_metadata_exists",
-        ok: false,
-        message: "Issue metadata records issue category and UI impact."
-      })
-    };
-  }
-
-  let metadata = null;
-  try {
-    metadata = JSON.parse(source);
-  } catch {
-    metadata = null;
-  }
-  const issueCategory = String(metadata?.issueCategory || "").trim().toLowerCase();
-  const uiImpact = String(metadata?.uiImpact || "").trim().toLowerCase();
-  const validIssueCategories = new Set(["client", "server", "client_server", "tooling", "unknown"]);
-  const validUiImpacts = new Set(["none", "possible", "definite", "unknown"]);
-  if (validIssueCategories.has(issueCategory) && validUiImpacts.has(uiImpact)) {
-    return {
-      ok: true,
-      precondition: createPrecondition({
-        id: "issue_metadata_exists",
-        ok: true,
-        message: "Issue metadata records issue category and UI impact."
-      })
-    };
-  }
-
-  return {
-    ok: false,
-    error: createError({
-      code: "issue_metadata_invalid",
-      message: "issue_metadata.json must include a valid issueCategory and uiImpact.",
-      repairCommand: jskitCommand(`session ${paths.sessionId} step --issue-details -`)
-    }),
-    precondition: createPrecondition({
-      id: "issue_metadata_exists",
-      ok: false,
-      message: "Issue metadata records issue category and UI impact."
-    })
-  };
-}
-
 async function assertIssueTextExists(paths) {
   const issueText = await readTrimmedFile(path.join(paths.sessionRoot, "issue.md"));
   if (issueText) {
@@ -512,7 +466,7 @@ async function assertIssueTextExists(paths) {
     error: createError({
       code: "issue_text_missing",
       message: "Cannot create a GitHub issue before issue.md exists.",
-      repairCommand: jskitCommand(`session ${paths.sessionId} step --issue -`)
+      repairCommand: jskitCommand(`session ${paths.sessionId} step`)
     }),
     precondition: createPrecondition({
       id: "issue_text_exists",
@@ -549,62 +503,6 @@ async function assertIssueUrlExists(paths) {
   };
 }
 
-async function assertPlanTextExists(paths) {
-  const activeCycle = await readTrimmedFile(path.join(paths.sessionRoot, "active_cycle"));
-  const planPath = path.join(paths.sessionRoot, "cycles", `cycle_${activeCycle || "001"}`, "plan.md");
-  const planText = await readTrimmedFile(planPath);
-  if (planText) {
-    return {
-      ok: true,
-      precondition: createPrecondition({
-        id: "plan_text_exists",
-        ok: true,
-        message: "Plan text exists."
-      })
-    };
-  }
-  return {
-    ok: false,
-    error: createError({
-      code: "plan_text_missing",
-      message: "Cannot execute a plan before the active cycle plan exists.",
-      repairCommand: jskitCommand(`session ${paths.sessionId} step --plan -`)
-    }),
-    precondition: createPrecondition({
-      id: "plan_text_exists",
-      ok: false,
-      message: "Plan text exists."
-    })
-  };
-}
-
-async function assertIssueDetailsExists(paths) {
-  const issueDetails = await readTrimmedFile(path.join(paths.sessionRoot, "issue_details.md"));
-  if (issueDetails) {
-    return {
-      ok: true,
-      precondition: createPrecondition({
-        id: "issue_details_exists",
-        ok: true,
-        message: "Issue details exist."
-      })
-    };
-  }
-  return {
-    ok: false,
-    error: createError({
-      code: "issue_details_missing",
-      message: "Cannot create a plan before issue_details.md exists.",
-      repairCommand: jskitCommand(`session ${paths.sessionId} step --issue-details -`)
-    }),
-    precondition: createPrecondition({
-      id: "issue_details_exists",
-      ok: false,
-      message: "Issue details exist."
-    })
-  };
-}
-
 async function assertBlueprintUpdateSatisfied(paths) {
   if (await pathExists(path.join(paths.sessionRoot, "steps", "blueprint_updated"))) {
     return {
@@ -631,28 +529,28 @@ async function assertBlueprintUpdateSatisfied(paths) {
   };
 }
 
-async function assertFinalReportExists(paths) {
-  if (await pathExists(path.join(paths.sessionRoot, "final_report.md"))) {
+async function assertPullRequestFileExists(paths) {
+  if (await pathExists(path.join(paths.sessionRoot, "pull_request.md"))) {
     return {
       ok: true,
       precondition: createPrecondition({
-        id: "final_report_exists",
+        id: "pull_request_file_exists",
         ok: true,
-        message: "Final report exists."
+        message: "Pull request draft exists."
       })
     };
   }
   return {
     ok: false,
     error: createError({
-      code: "final_report_missing",
-      message: "Cannot publish the PR before final_report.md exists.",
-      repairCommand: jskitCommand(`session ${paths.sessionId} step`)
+      code: "pull_request_file_missing",
+      message: "Cannot publish the PR before pull_request.md exists.",
+      repairCommand: jskitCommand(`session ${paths.sessionId} create_pull_request_file`)
     }),
     precondition: createPrecondition({
-      id: "final_report_exists",
+      id: "pull_request_file_exists",
       ok: false,
-      message: "Final report exists."
+      message: "Pull request draft exists."
     })
   };
 }
@@ -673,7 +571,7 @@ async function assertWorktreeExists(paths) {
     error: createError({
       code: "worktree_missing",
       message: "Session worktree does not exist.",
-      repairCommand: jskitCommand(`session ${paths.sessionId} step`)
+      repairCommand: jskitCommand(`session ${paths.sessionId} create_worktree`)
     }),
     precondition: createPrecondition({
       id: "worktree_exists",
@@ -711,8 +609,8 @@ async function assertPrUrlExists(paths) {
 }
 
 async function assertMainCheckoutSyncSatisfied(paths) {
-  const receiptPath = path.join(paths.sessionRoot, "steps", "main_checkout_synced");
-  if (await pathExists(receiptPath)) {
+  const recordPath = path.join(paths.sessionRoot, "steps", "main_checkout_synced");
+  if (await pathExists(recordPath)) {
     return {
       ok: true,
       precondition: createPrecondition({
@@ -742,21 +640,19 @@ export {
   assertAcceptedChangesCommitted,
   assertActiveCycleExists,
   assertActiveCycleUserCheckPassed,
+  assertUserCheckPassed,
   assertBlueprintUpdateSatisfied,
   assertDeepUiCheckSatisfied,
   assertDependenciesInstalled,
-  assertFinalReportExists,
+  assertPullRequestFileExists,
   assertGhAuth,
   assertGitCurrentBranch,
   assertGitRepository,
   assertGithubOrigin,
-  assertIssueMetadataExists,
   assertIssueTextExists,
   assertIssueUrlExists,
   assertAutomatedChecksPassed,
-  assertIssueDetailsExists,
   assertMainCheckoutSyncSatisfied,
-  assertPlanTextExists,
   assertPrUrlExists,
   assertReadyJskitApp,
   assertSessionExists,

package/src/server/sessionRuntime/promptRenderer.js

@@ -1,6 +1,5 @@
 import path from "node:path";
 import {
-  JSKIT_CLI_SHELL_RULE,
   PROMPT_DIRECTORY,
   SESSION_STATE_RELATIVE_PATH
 } from "./constants.js";
@@ -25,20 +24,9 @@ function renderTemplate(source, values = {}) {
   });
 }
 
-function withShellCommandRule(template) {
-  const body = String(template || "").trim();
-  if (!body) {
-    return JSKIT_CLI_SHELL_RULE;
-  }
-  if (body.includes("When running JSKIT CLI commands from the shell")) {
-    return body;
-  }
-  return `${JSKIT_CLI_SHELL_RULE}\n\n---\n\n${body}`;
-}
-
 async function renderPrompt(paths, templateName, values = {}) {
   const template = await readPromptTemplate(paths.targetRoot, templateName);
-  return renderTemplate(withShellCommandRule(template), {
+  return renderTemplate(template, {
     branch: paths.branch,
     session_id: paths.sessionId,
     worktree: paths.worktree,
@@ -49,6 +37,5 @@ async function renderPrompt(paths, templateName, values = {}) {
 export {
   readPromptTemplate,
   renderPrompt,
-  renderTemplate,
-  withShellCommandRule
+  renderTemplate
 };

package/src/server/sessionRuntime/prompts/app_blueprint.md

@@ -13,7 +13,7 @@ Before writing the blueprint, classify the app state if local files are availabl
 - partial_jskit_app
 - jskit_app
 
-Use these markers for a real JSKIT app when they exist:
+Recognize these files as signs of a real JSKIT app when they exist:
 
 - package.json
 - config/public.js
@@ -44,9 +44,4 @@ Cover:
 
 If the brief is ambiguous, state the assumption in the blueprint instead of asking questions. Do not invent detailed feature behavior that the brief does not support.
 
-When the blueprint is ready, output only the final markdown surrounded by these exact markers:
-
-[app_blueprint]
-# App Blueprint
-...
-[/app_blueprint]
+When the blueprint is ready, present the final Markdown starting with `# App Blueprint`.

package/src/server/sessionRuntime/prompts/{automated_checks.md → automated_checks_run.md}

@@ -16,7 +16,7 @@ Rules:
 - Prefer JSKIT-owned helpers, generators, package seams, agent docs, package descriptors, and documented commands over local hacks.
 - If a failure involves JSKIT architecture, generator ownership, CRUD, surfaces, placements, client/server contracts, or UI verification, read the relevant docs under `node_modules/@jskit-ai/agent-docs/` or `packages/agent-docs/` before repairing it.
 - Use `npx --no-install jskit ...` for JSKIT CLI commands you run directly from the shell.
-- Keep fixes scoped to the current issue, issue details, and active plan.
+- Keep fixes scoped to the current issue and worktree.
 - Do not create commits, branches, issues, pull requests, merges, or worktree cleanup. JSKIT session owns those steps.
 
 When finished, report:
@@ -25,19 +25,4 @@ When finished, report:
 - files changed
 - final check command and result
 - anything still unverified
-
-If the repair records a meaningful verification decision, tradeoff, missing coverage, or root-cause explanation future steps should know, include concise entries with reasons in this exact marker block:
-
-```text
-[agent_decisions]
-<verification or repair decisions, or "No new decisions.">
-[/agent_decisions]
-```
-
-At the very end, include this completion block so Studio knows the step is complete:
-
-[jskit_step_result]
-status: complete
-step: automated_checks_run
-summary: Short summary of the final check command, result, and any repairs.
-[/jskit_step_result]
+- any meaningful verification decision, tradeoff, missing coverage, or root-cause note future steps should know

package/src/server/sessionRuntime/prompts/{update_blueprint.md → blueprint_updated.md}

@@ -4,13 +4,10 @@ GitHub issue: {{issue_url}}
 Issue number: {{issue_number}}
 Issue title: {{issue_title}}
 Issue body file: {{issue_file}}
-Issue details file (`issue_details.md`): {{issue_details_file}}
-Plan file: {{plan_file}}
-Agent decisions file (`agent_decisions.md`): {{agent_decisions_file}}
 Current blueprint file (`.jskit/APP_BLUEPRINT.md`): {{app_blueprint_file}}
 Worktree: {{worktree}}
 
-Use the accepted issue work to update only durable app/product/architecture memory. Read the current blueprint when present, issue title/body, issue details, approved plan, agent decisions, helper map, package/app metadata, and changed files.
+Use the accepted issue work to update only durable app/product/architecture memory. Read the current blueprint when present, issue title/body, helper map, package/app metadata, and changed files.
 
 Changed files since the session base:
 
@@ -29,10 +26,4 @@ Rules:
 - Do not edit files other than `.jskit/APP_BLUEPRINT.md`.
 - Do not commit, branch, push, create PRs, merge, or clean up worktrees.
 
-When finished, summarize the blueprint result normally, then end with this exact marker:
-
-[jskit_step_result]
-status: complete
-step: blueprint_updated
-summary: Short summary of blueprint changes, or why no blueprint update was needed.
-[/jskit_step_result]
+When finished, summarize the blueprint changes, or why no blueprint update was needed.

package/src/server/sessionRuntime/prompts/{deep_ui_check.md → deep_ui_check_run.md}

@@ -5,9 +5,6 @@ GitHub issue: {{issue_url}}
 Issue number: {{issue_number}}
 Issue title: {{issue_title}}
 Issue body file: {{issue_file}}
-Issue details file (`issue_details.md`): {{issue_details_file}}
-Plan file: {{plan_file}}
-UI impact: {{ui_impact}}
 Worktree: {{worktree}}
 
 Changed files since the session base:
@@ -30,7 +27,7 @@ Check:
 - route and navigation coherence.
 - consistency with the existing app style.
 
-When clear scoped UI issues exist, fix them in the worktree. Keep fixes limited to the issue, confirmed issue details, and approved plan.
+When clear scoped UI issues exist, fix them in the worktree. Keep fixes limited to the issue.
 
 Use Playwright for a meaningful route check when possible. If login is required, use a development-only auth bootstrap path. When possible, record UI verification with:
 
@@ -40,18 +37,4 @@ Important: `npx --no-install jskit app verify-ui` does not start the app server.
 
 Do not create commits, branches, issues, pull requests, merges, or worktree cleanup. JSKIT session owns those steps.
 
-If this pass makes UI fixes, intentionally skips UI work after inspection, changes a design direction, or leaves a meaningful UI verification gap, include concise decision entries with reasons in this exact marker block:
-
-```text
-[agent_decisions]
-<Deep UI decisions or "No new decisions.">
-[/agent_decisions]
-```
-
-At the very end, include this completion block so Studio knows the step is complete:
-
-[jskit_step_result]
-status: complete
-step: deep_ui_check_run
-summary: Short summary of UI findings, fixes, verification, or why no UI work applied.
-[/jskit_step_result]
+When finished, summarize UI findings, fixes, verification, why no UI work applied, and any meaningful UI verification gaps.

package/src/server/sessionRuntime/prompts/final_report_created.md

@@ -0,0 +1,44 @@
+You are preparing the pull request draft for JSKIT session {{session_id}}.
+
+Write the pull request body to this exact file:
+
+{{pull_request_file}}
+
+Context:
+- Worktree: {{worktree}}
+- Issue: {{issue_url}}
+- Issue title: {{issue_title}}
+- Issue file: {{issue_file}}
+- Base branch: {{base_branch}}
+
+Files changed:
+{{files_changed}}
+
+Commits:
+{{commits}}
+
+Checks:
+{{checks}}
+
+UI checks:
+{{ui_checks}}
+
+Review passes:
+{{review_passes}}
+
+User check:
+{{user_check}}
+
+Blueprint:
+{{blueprint_status}}
+
+Command log:
+{{command_log}}
+
+Requirements:
+- Write only `pull_request.md` at the path above.
+- Do not create a GitHub pull request.
+- Do not run `gh`, `git push`, `git commit`, merge, or clean up the worktree.
+- Include any closing issue reference needed for GitHub to close the issue.
+- Keep the body useful to a reviewer: summary, key changes, verification, and any known gaps.
+- When done, briefly summarize that the file was written.

package/src/server/sessionRuntime/prompts/issue_created.md

@@ -0,0 +1,26 @@
+Create the canonical issue files from the scoped issue discussion in this Codex thread.
+
+Canonical issue body file to write: {{issue_file}}
+Canonical issue title file to write: {{issue_title_file}}
+
+Use the issue definition and scoping conversation that just happened in this terminal. If something is still materially unclear, ask the user before writing the files.
+
+Do not create a GitHub issue.
+Do not implement the change.
+Do not edit app code.
+Do not run generators, tests, installs, `gh`, `git add`, `git commit`, `git push`, or JSKIT workflow mutation commands.
+
+Write:
+
+- A short issue title to `{{issue_title_file}}`.
+- A concrete, implementation-ready issue body to `{{issue_file}}`.
+
+The issue body should include:
+
+- The requested change or bug clearly stated.
+- The accepted scope.
+- Important exclusions or non-goals.
+- Relevant implementation boundaries.
+- Acceptance criteria when useful.
+
+After writing the files, show the title and body in the terminal for user review.

package/src/server/sessionRuntime/prompts/issue_prompt_rendered.md

@@ -0,0 +1 @@
+You are helping the user define this issue before implementation. Treat the request above as the starting point and keep returning to it when deciding scope, exclusions, and acceptance criteria. Your job is to turn the request into a clear, scoped, implementation-ready issue through conversation. Be helpful to the user. Be a good software engineer who understands both the app being developed and the JSKIT framework being used, and provide practical advice that improves the issue before implementation starts. Do not create files. Do not write `issue.md`. Do not write `issue_title`. Do not create a GitHub issue. Do not implement the change. Do not edit app code. Do not run generators, tests, installs, `gh`, `git add`, `git commit`, `git push`, or JSKIT workflow mutation commands. You may inspect the app read-only when it helps scope the issue: use commands such as `pwd`, `ls`, `find`, `rg`, `cat`, `sed`, and `git status`; read package.json, `.jskit/lock.json`, config, routes, packages, source files, `.jskit/APP_BLUEPRINT.md`, and `.jskit/helper-map.md` when available; use non-mutating JSKIT inspection commands when available and relevant, such as `npx --no-install jskit list`, `npx --no-install jskit show <package> --details`, and `npx --no-install jskit list-placements`; if `jskit` is not on PATH, or `npx --no-install jskit ...` fails because a linked/devlinked JSKIT CLI cannot resolve a package such as `@jskit-ai/kernel`, treat that as a local development environment limitation and continue with filesystem inspection instead of trying to repair PATH, reinstall packages, publish packages, edit devlinks, or advance the JSKIT session; prefer JSKIT agent docs over reverse-engineering framework architecture from source files, starting with `node_modules/@jskit-ai/agent-docs/DISTR_AGENT.md`, `node_modules/@jskit-ai/agent-docs/guide/agent/index.md`, and `node_modules/@jskit-ai/agent-docs/patterns/INDEX.md` when present, or `packages/agent-docs/...` when working inside the JSKIT monorepo or a devlinked sibling. Only run shell commands when inspecting the app. Do not run `printf`, `echo`, `cat`, heredocs, or similar commands merely to display your own summary or communicate with the user. Engage with the user meaningfully: restate what you think the user wants; identify ambiguities, hidden constraints, and likely ownership boundaries; ask focused questions only when the answer would materially change scope or implementation; suggest a practical scope if the request is too broad; call out what should be excluded from this issue; and when the issue is clear enough, respond normally in the Codex conversation with the agreed scope, acceptance criteria, and any important implementation boundaries. Stop there. The user will continue to the next JSKIT step when they are satisfied with the scoped issue.

package/src/server/sessionRuntime/prompts/{plan_issue.md → make_plan.md}

@@ -1,45 +1,21 @@
 Create an implementation plan for JSKIT session {{session_id}}.
 
-Active cycle: {{active_cycle}}
-Plan source: {{plan_source}}
-
 GitHub issue: {{issue_url}}
 Issue number: {{issue_number}}
 Issue title: {{issue_title}}
 Issue body file: {{issue_file}}
 Issue title file: {{issue_title_file}}
-Issue details file (`issue_details.md`): {{issue_details_file}}
-Agent decisions file (`agent_decisions.md`): {{agent_decisions_file}}
 App blueprint file (`.jskit/APP_BLUEPRINT.md`): {{app_blueprint_file}}
-Plan file JSKIT will write after user approval: {{plan_file}}
 Worktree: {{worktree}}
 
-This planning step is read-only. Do not edit files, create session receipts, create or overwrite the plan file, create commits, create branches, create issues, create pull requests, merge, or clean worktrees. JSKIT will save the approved plan to the plan file after the user reviews it.
-
-If Plan source is `issue`, create the plan from the issue and confirmed issue details.
-
-If Plan source is `rework`, create a revised plan from the user's rework request for this cycle. Preserve the original issue constraints, but focus the plan on fixing the reported problem.
-
-Rework request file: {{rework_request_file}}
-
-Rework request:
-
-{{rework_request}}
+This planning step is read-only for app code. Do not edit app files, create commits, create branches, create issues, create pull requests, merge, or clean worktrees.
 
-Read the issue, confirmed issue details, rework request when present, agent decisions, and local app before planning. Use the issue files, issue details file, package.json, .jskit metadata, config, packages, routes, generated references, package docs, any saved app blueprint, and `.jskit/helper-map.md` when available.
+Create the plan from the issue and local app. Use the issue files, package.json, .jskit metadata, config, packages, routes, generated references, package docs, any saved app blueprint, and `.jskit/helper-map.md` when available.
 
 Before deriving JSKIT architecture from source files, read the package-owned agent docs that apply to this work. Start with `node_modules/@jskit-ai/agent-docs/DISTR_AGENT.md`, `node_modules/@jskit-ai/agent-docs/guide/agent/index.md`, and `node_modules/@jskit-ai/agent-docs/patterns/INDEX.md` when present. If the worktree is the JSKIT monorepo or a devlinked sibling, use the equivalent `packages/agent-docs/...` paths. Then read the specific pattern docs needed for the lane, such as `patterns/crud-scaffolding.md`, `patterns/crud-repository-mapping.md`, `patterns/page-scaffolding.md`, `patterns/placements.md`, `patterns/surfaces.md`, `patterns/client-requests.md`, `patterns/live-actions.md`, `patterns/generated-ui-contract-tracking.md`, or `patterns/ui-testing.md`.
 
 If these docs are unavailable, continue with app inspection and say that the agent docs were unavailable. Do not compensate by inventing framework rules from isolated source files.
 
-Confirmed issue details:
-
-{{issue_details_text}}
-
-Known decisions:
-
-{{agent_decisions_text}}
-
 Start by identifying the implementation lane:
 
 - package install
@@ -50,7 +26,7 @@ Start by identifying the implementation lane:
 Planning rules:
 
 - Keep the plan scoped to the issue. Avoid "while I am here" work.
-- Follow the confirmed issue details and preserve the issue category and UI impact in the plan. If details are insufficient, say exactly what is missing instead of inventing foundational details.
+- If details are insufficient, say exactly what is missing instead of inventing foundational details.
 - Prefer vertical slices that produce visible or end-to-end progress.
 - If the work is too broad to review confidently, split it into clear chunks.
 - Make generator decisions concrete. Name the exact `npx --no-install jskit` commands to run when a generator or package install applies.
@@ -67,20 +43,15 @@ Planning rules:
 - For package-owned baseline workflows, plan to install and verify the baseline before inventing custom code around it.
 - For user-facing UI, include Material/Vuetify quality expectations and a Playwright verification path.
 - If login is required for UI verification, plan for a development-only auth bootstrap path instead of live external auth.
-- Do not create or update the old `.jskit/WORKBOARD.md` workflow. JSKIT session state, receipts, issue text, plan file, transcript, and commits are the tracker.
+- Do not create or update the old `.jskit/WORKBOARD.md` workflow. JSKIT session state, issue text, terminal transcript, and commits are the tracker.
 
 If setup values are needed, ask plainly using exact env var or option names. For example: DB_NAME, DB_USER, DB_PASSWORD, DB_HOST, DB_PORT, AUTH_SUPABASE_URL, AUTH_SUPABASE_PUBLISHABLE_KEY, APP_PUBLIC_URL.
 
 If the issue is not clear enough to plan safely, ask the user concise follow-up questions first.
 
-When the plan is ready, output only the final plan for this cycle and any new decisions surrounded by these exact markers:
-
-[plan]
-<implementation plan in Markdown>
-[/plan]
+When the plan is ready:
 
-[agent_decisions]
-<new planning decisions with reasons, or "No new decisions.">
-[/agent_decisions]
+- Present the final plan and any new decisions clearly in the terminal for the user to review.
+- Do not write a plan file.
 
-Keep the plan concrete and implementation-oriented. Include the issue category, UI impact, likely files or areas to touch, ordered steps, generator commands to consider, review expectations, and checks that should be run.
+Keep the plan concrete and implementation-oriented. Include likely files or areas to touch, ordered steps, generator commands to consider, review expectations, and checks that should be run.