@jskit-ai/agent-docs 0.1.44 → 0.1.46

package/guide/agent/app-setup/initial-scaffolding.md

@@ -28,20 +28,7 @@ npx @jskit-ai/create-app exampleapp --target . --force --tenancy-mode <mode>
 npm install
 ```
 
-After that promotion, the overwritten app `AGENTS.md` stays deliberately small. Use `jskit session` for issue-driven work; session state and prompts live under `.jskit/sessions/` in the target app.
-
-Issue sessions are executable workflow state, not prose instructions. The important durable files are:
-
-- `issue.md` and `issue_title` for the approved GitHub issue.
-- `plan_details.md` for the confirmed implementation details gathered before planning.
-- `plan.md` for the approved implementation plan.
-- `agent_decisions.md` for concise decisions and why they were made.
-- `.jskit/APP_BLUEPRINT.md` for durable app/product/architecture memory that grows across issues.
-- `review_passes/`, `checks/`, `ui_checks/`, and `command_log.jsonl` for review, verification, UI check, and command receipts.
-
-The Deep UI Check steps use the saved issue classification: server-only work can be skipped with a receipt, possible UI work can be skipped only with an explicit reason, and definite UI work must run. If the User Check fails, JSKIT starts a new cycle under `cycles/cycle_###/` and cycle-scoped receipts under `steps/cycle_###/`; do not delete older cycle receipts.
-
-Studio and other tools should read `jskit session <session_id> --json` rather than scraping those files directly. Manual agents should follow the current `jskit session <session_id> step` output and avoid recreating the old workboard workflow.
+After that promotion, the overwritten app `AGENTS.md` stays deliberately small. Use it with the distributed JSKIT agent docs when planning or implementing app changes. The durable app memory lives in `.jskit/APP_BLUEPRINT.md` and should describe product and architecture decisions, not become an implementation task list.
 
 After creating the real app scaffolding (the base shell, not the seed wrapper), you will need to run `npm install` to install dependencies.
 

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@jskit-ai/agent-docs",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "Distributed JSKIT agent references, prompts, guides, and generated reference maps.",
   "type": "module",
   "files": [
-    "DISTR_AGENT.md",
     "guide",
     "patterns",
     "reference",
@@ -23,7 +22,6 @@
   "keywords": [
     "jskit",
     "agent",
-    "docs",
-    "session"
+    "docs"
   ]
 }

package/reference/autogen/tooling/jskit-cli.md

@@ -25,6 +25,7 @@ Exports
 ### `src/server/appBlueprint.js`
 Exports
 - `APP_BLUEPRINT_RELATIVE_PATH`
+- `APP_BLUEPRINT_PROMPT_DIRECTORY`
 - `APP_PROMPT_OVERRIDE_RELATIVE_ROOT`
 - `extractAppBlueprintText(value = "")`
 - `readAppBlueprint({ targetRoot = process.cwd() } = {})`
@@ -33,6 +34,11 @@ Exports
 - `resolveAppBlueprintPaths(targetRoot = process.cwd())`
 - `writeAppBlueprint({ targetRoot = process.cwd(), appBlueprint = "" } = {})`
 Local functions
+- `normalizeText(value)`
+- `fileExists(filePath)`
+- `readTextIfExists(filePath)`
+- `writeTextFile(filePath, value)`
+- `renderTemplate(source, values = {})`
 - `readAppPromptTemplate(paths, templateName)`
 
 ### `src/server/cliEntrypoint.js`
@@ -670,23 +676,6 @@ Local functions
 Exports
 - `runPackageUpdateCommand(ctx = {}, { positional, options, cwd, io }, { runCommandAdd })`
 
-### `src/server/commandHandlers/session.js`
-Exports
-- `createSessionCommands()`
-Local functions
-- `writeJson(stdout, payload)`
-- `writeSessionText(stdout, payload)`
-- `readStream(stream)`
-- `resolveInputFilePath(cwd, filePath)`
-- `resolveTextInput({ codePrefix, fileOption, inlineOptions = {}, io = {}, repairCommand, cwd, stdinOption, textOption, sessionId })`
-- `resolveStepInputs({ inlineOptions = {}, io = {}, cwd, sessionId })`
-- `normalizeStepOptions(inlineOptions = {})`
-- `resolveListArchiveOption(options = {})`
-- `runSessionStepCommand({ cwd, inlineOptions = {}, io = {}, sessionId })`
-- `runNextSessionStep({ cwd, sessionId })`
-- `runSkipSessionStep({ cwd, inlineOptions = {}, io = {}, sessionId })`
-- `runDeslopSessionStep({ cwd, sessionId })`
-
 ### `src/server/commandHandlers/shared.js`
 Exports
 - `createCommandHandlerShared(ctx = {})`
@@ -811,337 +800,6 @@ Exports
 Exports
 - `runCli`
 
-### `src/server/sessionRuntime.js`
-Exports
-- `SESSION_STATUS`
-- `STEP_DEFINITIONS`
-- `STEP_IDS`
-- `STEP_PRECONDITION_NAMES`
-- `abandonSession({ targetRoot = process.cwd(), sessionId } = {})`
-- `advanceSessionStep({ targetRoot = process.cwd(), sessionId } = {})`
-- `adoptDependenciesInstalled({ targetRoot = process.cwd(), sessionId, message = "" } = {})`
-- `adoptCodexThreadId({ targetRoot = process.cwd(), sessionId, codexThreadId } = {})`
-- `buildSessionResponse`
-- `buildSessionErrorResponse`
-- `createSession({ targetRoot = process.cwd(), sessionId = "", now = new Date() } = {})`
-- `createSessionId`
-- `extractIssueTitle(value = "")`
-- `extractIssueText(value = "")`
-- `inspectSession({ targetRoot = process.cwd(), sessionId } = {})`
-- `inspectSessionDiff({ targetRoot = process.cwd(), sessionId } = {})`
-- `inspectSessionDetails({ targetRoot = process.cwd(), sessionId } = {})`
-- `isValidSessionId`
-- `listSessions({ targetRoot = process.cwd(), archive = "active" } = {})`
-- `renderTemplate`
-- `recordDependenciesInstalled(paths, { message = "Installed Node dependencies in the session worktree.", preconditions = [] } = {})`
-- `rewindSession({ targetRoot = process.cwd(), sessionId, stepId } = {})`
-- `resolveSessionPaths`
-- `runSessionStep({ targetRoot = process.cwd(), sessionId, options = {} } = {})`
-- `runSessionStepAction({ targetRoot = process.cwd(), sessionId, action, options = {} } = {})`
-Local functions
-- `invalidSessionIdError(sessionId = "")`
-- `invalidSessionIdResponse({ targetRoot, sessionId })`
-- `existingSessionContext({ targetRoot = process.cwd(), sessionId } = {})`
-- `withExistingSession(input, handler)`
-- `extractMarkedText(value = "", marker = "")`
-- `writePromptArtifact(paths, fileName, prompt)`
-- `commandText(command, args = [])`
-- `cycleRootPath(paths, cycle)`
-- `commandOutputSummary(output = "")`
-- `appendCommandLog(paths, { args = [], command, cwd = "", kind = "command", result } = {})`
-- `runLoggedCommand(paths, kind, command, args = [], options = {})`
-- `readWorktreePackageJson(worktree)`
-- `packageScriptRunArgs(packageManager, scriptName)`
-- `packageScriptCommandForWorktree(worktree, scriptName, { preferredPackageManager = "" } = {})`
-- `sessionPackageScriptEnv(paths, scriptName)`
-- `packageScriptRepairCommand(paths, command, args)`
-- `packageScriptRecordName(scriptName)`
-- `writeSessionHookRecord(paths, scriptName, message)`
-- `runOptionalSessionPackageScript(paths, { failureCode, failureMessage, kind, preferredPackageManager = "", preconditions = [], scriptName, timeout = 1000 * 60 * 10 } = {})`
-- `runSessionFinalizationGuard(paths, preconditions = [])`
-- `runSessionProvisioningHook(paths, { preferredPackageManager = "", preconditions = [] } = {})`
-- `readGithubComments(paths)`
-- `writeGithubComments(paths, comments = {})`
-- `commentOnIssueOnce(paths, { bodyFile, issueUrl, purpose })`
-- `issueMetadataFromUrl(issueUrl = "")`
-- `writeIssueMetadataFiles(paths, { issueTitle = "", issueUrl = "" } = {})`
-- `normalizeArchiveFilter(archive = "active")`
-- `emptySessionDetails(response)`
-- `removeEmptyStaleWorktreeDirectory(paths)`
-- `createWorktree(paths, _options = {}, context = {})`
-- `recordDependencyInstallResult(paths, { message = "Installed Node dependencies in the session worktree.", preconditions = [] } = {})`
-- `parsePackageManager(value = "")`
-- `hasWorktreeFile(worktree, fileName)`
-- `dependencyInstallCommandForWorktree(worktree)`
-- `installDependencies(paths, _options = {}, context = {})`
-- `issueDefinitionPrompt(userInput, context)`
-- `renderIssuePrompt(paths, options = {}, context = {})`
-- `titleFromIssue(issueText)`
-- `createIssue(paths, _options = {}, context = {})`
-- `submitIssue(paths, _options = {}, context = {})`
-- `renderIssueFilePrompt(paths, context = {})`
-- `makePlan(paths, _options = {}, context = {})`
-- `renderPlanExecutionPrompt(paths, _options = {}, context = {})`
-- `worktreeStatus(worktree)`
-- `untrackedFiles(worktree)`
-- `untrackedFileDiff(worktree, filePath)`
-- `untrackedFilesDiff(worktree)`
-- `removeSessionPath(paths, ...parts)`
-- `removeSessionRootFile(paths, fileName)`
-- `removePromptArtifact(paths, fileName)`
-- `removeGlobalCodexResult(paths, stepId)`
-- `removeCycleCodexResults(paths, stepId)`
-- `removeCodexResult(paths, stepId)`
-- `removeGithubCommentPurpose(paths, purpose)`
-- `removeCycleDirectories(paths)`
-- `removePlanArtifacts(paths)`
-- `removePlanExecutionArtifacts(paths)`
-- `targetIsAllowedRewindStep(stepId)`
-- `deletedStepIdsForRewindTarget(stepId)`
-- `removeStepRecordsForDeletedSteps(paths, deletedStepIds)`
-- `cancelDeletedStepArtifacts(paths, deletedStepIds)`
-- `commitWorktree(paths, { message, allowNoChanges = false } = {})`
-- `uniqueChangedFileList(entries = [])`
-- `changedFilesInWorktree(paths)`
-- `blueprintBaselinePath(paths)`
-- `isBlueprintRelativePath(filePath = "")`
-- `nonBlueprintChangedFiles(files = [])`
-- `hashWorktreeFile(paths, filePath)`
-- `buildDirtyFileSnapshot(paths, files = [])`
-- `writeBlueprintBaseline(paths)`
-- `readBlueprintBaseline(paths)`
-- `unexpectedBlueprintStepChanges(paths, changedFiles = [])`
-- `changedFilesSinceBase(paths)`
-- `nextReviewPassNumber(pass = "")`
-- `readCurrentReviewPass(paths)`
-- `writeCurrentReviewPass(paths, pass)`
-- `resolveReviewPassForPrompt(paths)`
-- `writeReviewPassJson(paths, pass, fileName, payload)`
-- `currentHead(paths)`
-- `renderReviewPrompt(paths)`
-- `renderResolveDeslopPrompt(paths, context = {})`
-- `acceptReviewChanges(paths, options = {}, context = {})`
-- `runAutomatedChecks(paths, { stepId }, _options = {}, context = {})`
-- `writeUiCheckJson(paths, fileName, payload)`
-- `runDeepUiCheck(paths, { stepId, phase }, _options = {}, context = {})`
-- `userCheck(paths, options = {})`
-- `readAcceptedChangesCommit(paths)`
-- `commitAcceptedChanges(paths, _options = {}, context = {})`
-- `updateBlueprint(paths, _options = {}, context = {})`
-- `readPackageJson(root)`
-- `doctorCommandForWorktree(worktree)`
-- `commitLinesSinceBase(paths)`
-- `readCheckSummaries(paths)`
-- `readUiCheckSummaries(paths)`
-- `readReviewPassSummaries(paths)`
-- `renderPullRequestFilePrompt(paths, context = {})`
-- `createPullRequestFile(paths, _options = {}, context = {})`
-- `issueNumberFromUrl(issueUrl)`
-- `parseJsonObject(value)`
-- `booleanOption(options = {}, ...names)`
-- `skipStepRequested(options = {})`
-- `skipStepReason(options = {}, stepId = "")`
-- `writeJsonFile(filePath, payload)`
-- `writeTextIfMissing(filePath, value)`
-- `writeSkippedIssueDraft(paths, reason)`
-- `writeSkippedReviewPass(paths, reason)`
-- `writeSkippedStepArtifacts(paths, stepId, reason)`
-- `skipCurrentStep(paths, stepId, options = {})`
-- `readPrState(paths, prUrl)`
-- `readCurrentBranchPrState(paths)`
-- `prStateIsMerged(prState)`
-- `prStateIsClosed(prState)`
-- `currentTargetBranch(targetRoot)`
-- `assertTargetRootCleanForBaseUpdate(paths)`
-- `removeSessionWorktree(paths)`
-- `writePrOutcome(paths, outcome)`
-- `mainCheckoutSyncPath(paths)`
-- `writeMainCheckoutSync(paths, payload = {})`
-- `assertTargetRootCanUpdateBase(paths, branch)`
-- `updateLocalBaseBranch(paths, baseBranch = "")`
-- `syncMainCheckout(paths, options = {}, context = {})`
-- `updateHelperMapBeforePr(paths)`
-- `createPr(paths, _options = {}, context = {})`
-- `preparePrMerge(paths, options = {}, context = {})`
-- `finalizePr(paths, options = {}, context = {})`
-- `finishSession(paths)`
-- `runNamedPreconditions(paths, names = [])`
-- `sessionStepError(paths, { code, message, repairCommand = "" } = {})`
-- `createIssueFileAction(paths, options = {}, context = {})`
-- `createGithubIssueAction(paths, options = {}, context = {})`
-
-### `src/server/sessionRuntime/appReadiness.js`
-Exports
-- `inspectReadyJskitAppRoot(rootPath)`
-Local functions
-- `pathExists(filePath)`
-- `directoryExists(filePath)`
-
-### `src/server/sessionRuntime/constants.js`
-Exports
-- `PROMPT_DIRECTORY`
-- `SESSION_ID_PATTERN`
-- `SESSION_STATUS`
-- `SESSION_WORKFLOW_VERSION`
-- `DEPENDENCIES_INSTALL_RESULT_FILE`
-- `REVIEW_PASS_LIMIT`
-- `CYCLE_STEP_IDS`
-- `STEP_DEFINITION_BY_ID`
-- `STEP_DEFINITIONS`
-- `STEP_IDS`
-- `STEP_LABEL_BY_ID`
-- `STEP_PRECONDITION_NAMES`
-- `ISSUE_DEFINITION_CODEX_HANDOFF`
-- `ISSUE_FILE_CODEX_HANDOFF`
-- `PLAN_CODEX_HANDOFF`
-- `PLAN_EXECUTION_CODEX_HANDOFF`
-- `REVIEW_EXECUTION_CODEX_HANDOFF`
-- `RESOLVE_DESLOP_CODEX_HANDOFF`
-- `DEEP_UI_CHECK_CODEX_HANDOFF`
-- `AUTOMATED_CHECK_REPAIR_CODEX_HANDOFF`
-- `BLUEPRINT_CODEX_HANDOFF`
-- `PR_FILE_CODEX_HANDOFF`
-- `PR_MERGE_PREP_CODEX_HANDOFF`
-- `JSKIT_CLI_SHELL_COMMAND`
-- `SESSION_STATE_RELATIVE_PATH`
-Local functions
-- `codexHandoff({ promptActionLabel = "", promptIntroText = "", promptWaitingText = "", sendPrompt = false } = {})`
-- `stepAutomationFor({ codex = undefined, id, kind, requiresExplicitRun = false })`
-- `defineStep({ buttonLabel, codex = undefined, description, id, input = INPUT_NONE, kind = "automatic", label, nextCommandTemplate = DEFAULT_NEXT_COMMAND_TEMPLATE, preconditions = [], requiresExplicitRun = false, submitOptions = {}, automation = undefined, utilityActions = [], displayGroupId = "", displayGroupLabel = "" })`
-
-### `src/server/sessionRuntime/io.js`
-Exports
-- `fileExists(filePath)`
-- `normalizeText(value)`
-- `readTextIfExists(filePath)`
-- `readTrimmedFile(filePath)`
-- `runCommand(command, args = [], { cwd, env = {}, timeout = 30000 } = {})`
-- `runGit(targetRoot, args = [], options = {})`
-- `runGitInWorktree(worktree, args = [], options = {})`
-- `timestampForStepRecord(now = new Date())`
-- `writeTextFile(filePath, value)`
-
-### `src/server/sessionRuntime/paths.js`
-Exports
-- `archiveSession(paths, archive)`
-- `createAvailableSessionId(targetRoot, now = new Date())`
-- `createSessionId(now = new Date())`
-- `isValidSessionId(sessionId = "")`
-- `normalizeSessionId(sessionId = "")`
-- `resolveExistingSessionRoot(paths)`
-- `resolveSessionPaths({ targetRoot, sessionId = "" } = {})`
-- `pathsForExistingSession(paths)`
-Local functions
-- `formatDatePart(value)`
-
-### `src/server/sessionRuntime/preconditions.js`
-Exports
-- `applyPreconditions(paths, checks = [])`
-- `assertAcceptedChangesCommitted(paths)`
-- `assertActiveCycleExists(paths)`
-- `assertActiveCycleUserCheckPassed(paths)`
-- `assertUserCheckPassed(paths)`
-- `assertBlueprintUpdateSatisfied(paths)`
-- `assertDeepUiCheckSatisfied(paths)`
-- `assertDependenciesInstalled(paths)`
-- `assertPullRequestFileExists(paths)`
-- `assertGhAuth(targetRoot)`
-- `assertGitCurrentBranch(targetRoot)`
-- `assertGitRepository(targetRoot)`
-- `assertGithubOrigin(targetRoot)`
-- `assertIssueTextExists(paths)`
-- `assertIssueUrlExists(paths)`
-- `assertAutomatedChecksPassed(paths)`
-- `assertMainCheckoutSyncSatisfied(paths)`
-- `assertPrUrlExists(paths)`
-- `assertReadyJskitApp(paths)`
-- `assertSessionExists(paths)`
-- `assertTargetRootWritable(targetRoot)`
-- `assertWorktreeExists(paths)`
-- `ensureStudioGitExclude(targetRoot)`
-- `hasWorktree`
-Local functions
-- `jskitCommand(args = "")`
-- `resolveGitCommonDirectory(targetRoot)`
-- `pathExists(filePath)`
-- `assertActiveCycleStepRecord(paths, { code, id, message, stepId })`
-
-### `src/server/sessionRuntime/promptRenderer.js`
-Exports
-- `readPromptTemplate(targetRoot, name)`
-- `renderPrompt(paths, templateName, values = {})`
-- `renderTemplate(source, values = {})`
-
-### `src/server/sessionRuntime/responses.js`
-Exports
-- `buildSessionErrorResponse({ targetRoot = process.cwd(), sessionId = "", code, message, repairCommand = "", status = SESSION_STATUS.BLOCKED, preconditions = [], errors = undefined } = {})`
-- `buildSessionResponse(paths, { codex = undefined, ok = true, errors = [], preconditions = [], prompt = undefined, status = undefined, warnings = [] } = {})`
-- `buildStepDefinitions()`
-- `createError({ code, message, repairCommand = "" })`
-- `createPrecondition({ id, ok, message })`
-- `failSession(paths, { code, message, repairCommand = "", preconditions = [], status = SESSION_STATUS.BLOCKED, prompt = "", codex = undefined })`
-- `markCurrentStep(paths, stepId)`
-- `markStatus(paths, status)`
-- `normalizeReviewPassNumber(value = "")`
-- `readActiveCycle(paths)`
-- `readStepRecords(paths)`
-- `readReviewPasses(paths)`
-- `readSessionArtifacts(paths)`
-- `reviewPassDirectoryName(pass = DEFAULT_REVIEW_PASS)`
-- `reviewPassRoot(paths, pass)`
-- `writeCycleStepRecord(paths, recordName, message, { cycle = "" } = {})`
-- `writeStepRecord(paths, stepId, message)`
-Local functions
-- `createWarning({ code, message, repairCommand = "" })`
-- `issueNumberFromUrl(issueUrl = "")`
-- `normalizeStepId(stepId)`
-- `stepIndex(stepId)`
-- `normalizeKnownStepIds(stepIds = [])`
-- `stepCanExposeStoredPrompt(stepId)`
-- `normalizeCycleNumber(value = "")`
-- `cycleDirectoryName(cycle = DEFAULT_ACTIVE_CYCLE)`
-- `isCycleStepId(stepId = "")`
-- `readWorkflowVersion(paths)`
-- `cycleStepsRoot(paths, cycle)`
-- `cycleRoot(paths, cycle)`
-- `parseJsonFileIfExists(filePath)`
-- `readReviewPassNumbers(paths)`
-- `readReviewPassInfo(paths, pass)`
-- `latestReviewPass(artifacts = {})`
-- `latestReviewPassIsPrompted(artifacts = {})`
-- `readPromptFromAbsolutePath(filePath = "")`
-- `readReviewPromptForStep(paths, artifacts = {})`
-- `readPromptForStep(paths, stepId, artifacts = {})`
-- `readStepFileNames(stepsRoot)`
-- `readCompletedSteps(paths)`
-- `applyReviewPassCompletionOverlay(paths, completedSteps = [])`
-- `readCycleInfo(paths, cycle)`
-- `readCycles(paths, activeCycle)`
-- `readStructuredChecks(paths)`
-- `readStructuredUiChecks(paths)`
-- `readWorktreeStatus(paths, worktreeReady)`
-- `resolveNextStep(completedSteps = [])`
-- `cloneContractValue(value)`
-- `normalizeWarning(warning)`
-- `mergeWarnings(...warningLists)`
-- `publicCodexContract(codex = null)`
-- `stepRepeatabilityContract(stepId)`
-- `publicStepDefinition(step, index)`
-- `stepIsRetryableWhenBlocked(stepId)`
-- `uiCheckPromptedForStep(artifacts = {}, stepId = "")`
-- `skipReasonForStep(stepId, artifacts = {})`
-- `buildCurrentStepAction(stepId, artifacts = {})`
-- `rawCodexHandoff(stepId, artifacts = {})`
-- `buildCodexHandoff(stepId, artifacts = {})`
-- `stepCanExposeNextCommand(stepId, artifacts = {})`
-- `buildNextCommand(sessionId, stepId, artifacts = {})`
-- `buildStepActionCommands(sessionId, stepId, artifacts = {})`
-
-### `src/server/sessionRuntime/worktrees.js`
-Exports
-- `hasWorktree(paths = {})`
-- `parseGitWorktreeList(output = "")`
-
 ### `src/server/shared/cliError.js`
 Exports
 - `createCliError(message, { showUsage = false, exitCode = 1, renderUsage = null } = {})`

package/skills/jskit-review/SKILL.md

@@ -15,7 +15,7 @@ Preferred execution mode:
 
 ## Read First
 
-Use the current `jskit session` review prompt as the source of truth when the review is part of a session.
+Use the user request, current diff, and app-local instructions as the source of truth for the review scope.
 
 Read these on demand:
 
@@ -24,11 +24,6 @@ Read these on demand:
 - `../../guide/agent/index.md`
 - `../../site/guide/index.md` when compressed guidance is ambiguous
 
-Inspect app-local session files when they exist:
-
-- `.jskit/sessions/active/<session_id>/prompt.md`
-- `.jskit/sessions/active/<session_id>/issue.md`
-
 ## Review target
 
 Determine whether the target is:
@@ -36,8 +31,6 @@ Determine whether the target is:
 - the current chunk
 - or the whole changeset
 
-Use the active `jskit session` state to determine the current pass when available.
-
 ## Required passes
 
 1. Deslop review

package/templates/app/AGENTS.md

@@ -1,13 +1,10 @@
 # App Agent Instructions
 
-Use JSKIT sessions for issue work.
+Use the JSKIT agent docs and the local app scaffold as the source of truth for app work.
 
-Use:
+Recommended references:
 
-- `jskit session`
-- `jskit session create`
-- `jskit session <session_id>`
-- `jskit session <session_id> step`
-- `jskit session <session_id> step --json` for tools and UIs
+- `node_modules/@jskit-ai/agent-docs/guide/agent/index.md`
+- `node_modules/@jskit-ai/agent-docs/patterns/INDEX.md`
 
-Follow the current session step output and prompt. Do not invent a parallel manual issue workflow.
+Keep changes scoped to the user request and verify runtime behavior with tests or explicit checks.