@ahumandev/autocode 0.0.2 → 0.0.4

package/dist/plugin.js

@@ -786,40 +786,61 @@ async function updateCurrentSessionTitleToJobName(client, context, jobName, stat
 async function ensurePlannedJobFiles(fileSystem, directoryPath) {
   await fileSystem.mkdir(directoryPath, { recursive: true });
 }
-async function moveResolvedPlannedJobToStatus(worktree, source, status, fileSystem = defaultMoveJobFileSystem) {
+function formatTimestampPostfix(date = new Date) {
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${String(date.getFullYear()).slice(-2)}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}_${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
+}
+function createShelvedCollisionJobName(jobName, date = new Date) {
+  return `${jobName}_${formatTimestampPostfix(date)}`;
+}
+async function moveResolvedPlannedJobToStatus(worktree, source, status, fileSystem = defaultMoveJobFileSystem, options = {}) {
   const destinationDirectory = getCanonicalDirectoryForStatus(status);
-  const destinationDir = getJobDirectoryPath(worktree, destinationDirectory, source.job_name);
+  let destinationJobName = source.job_name;
+  let destinationDir = getJobDirectoryPath(worktree, destinationDirectory, destinationJobName);
   if (source.absolute_path !== destinationDir) {
     await fileSystem.mkdir(getJobDirectoryPath(worktree, destinationDirectory, ""), { recursive: true });
     try {
       await fileSystem.rename(source.absolute_path, destinationDir);
     } catch (error) {
       if (isCollisionError(error)) {
-        return { type: "destination_collision", destinationDir };
+        if (status !== "shelved" || !options.shelvedCollisionTimestamp) {
+          return { type: "destination_collision", destinationDir };
+        }
+        destinationJobName = createShelvedCollisionJobName(source.job_name, options.shelvedCollisionTimestamp);
+        destinationDir = getJobDirectoryPath(worktree, destinationDirectory, destinationJobName);
+        try {
+          await fileSystem.rename(source.absolute_path, destinationDir);
+        } catch (retryError) {
+          if (isCollisionError(retryError)) {
+            return { type: "destination_collision", destinationDir };
+          }
+          throw retryError;
+        }
+      } else {
+        throw error;
       }
-      throw error;
     }
   }
   await ensurePlannedJobFiles(fileSystem, destinationDir);
   return {
     type: "success",
     job: {
-      job_name: source.job_name,
+      job_name: destinationJobName,
       status,
       directory: destinationDirectory,
       absolute_path: destinationDir,
-      job_path: getRelativeJobDirectoryPath(destinationDirectory, source.job_name),
-      relative_job_path: getRelativeJobDirectoryPath(destinationDirectory, source.job_name)
+      job_path: getRelativeJobDirectoryPath(destinationDirectory, destinationJobName),
+      relative_job_path: getRelativeJobDirectoryPath(destinationDirectory, destinationJobName)
     },
     from_status: source.status
   };
 }
-async function movePlannedJobToStatus(worktree, jobName, status, fileSystem = defaultMoveJobFileSystem) {
+async function movePlannedJobToStatus(worktree, jobName, status, fileSystem = defaultMoveJobFileSystem, options = {}) {
   const resolved = await resolvePlannedJob(fileSystem, worktree, jobName);
   if (resolved.type !== "found") {
     return resolved.type === "missing" ? { type: "missing" } : { type: "collision", collision: resolved.collision };
   }
-  return moveResolvedPlannedJobToStatus(worktree, resolved.job, status, fileSystem);
+  return moveResolvedPlannedJobToStatus(worktree, resolved.job, status, fileSystem, options);
 }
 async function findExistingJobFile(fileSystem, worktree, job, fileName, directories = [...activeJobLifecycleDirectories, completedJobLifecycleDirectory]) {
   const matches = [];
@@ -1932,7 +1953,6 @@ Caveman English applies to: tool parameters, prompts, user responses (excluding
 - Option labels in Caveman English
 - Option descriptions in Caveman English and summarize agent prompt if chosen (max 30 words).
 - If multiple choices may be selected together, set \`"multiple": true\`; otherwise set \`"multiple": false\` on question object.
-- NEVER include catch-all options like "Other".
 
 ### Batching
 - Prefer batching related questions into single \`question\` tool call.
@@ -2034,9 +2054,9 @@ function getMarkdownBody(markdown2) {
   return stripLeadingYamlFrontMatter(markdown2).trim();
 }
 
-// src/agents/rules/swap2assist.ts
-var swap2assistRule = `
-**IMPORTANT FINAL ACTION**: call \`autocode_agent_swap\` with \`agent=assist\` to follow Next Action according to Assistant Workflow.
+// src/agents/rules/swap2previous.ts
+var swap2previousRule = `
+**IMPORTANT FINAL ACTION**: call \`autocode_agent_previous\`.
 `;
 
 // src/agents/prompts/temp_manual.ts
@@ -2088,7 +2108,7 @@ Follow this workflow to perform DANGEROUS OPERATIONS or user responsibilities:
 		1. You are only allowed to perform ONLY that specific DANGEROUS OPERATION on user's behalf
 	 	2. Next DANGEROUS OPERATION is user's responsibility again.
 
-${swap2assistRule}
+${swap2previousRule}
 
 ---
 
@@ -2139,14 +2159,15 @@ ${manualRules}
 ## Assistant Workflow
 
 1. Next user request = your assignment
-2. Determine assignment resolution:
-    - Need more info / has uncertainties / multiple good resolutions exist: then repeatedly interview user with \`question\` tool by suggesting options until clear.
-    - Already have all required info and only 1 good resolution exists: then tell user next action with emojis in Concise English (max 20 words) and then proceed with assignment.
-3. Complete the assignment by tasking subagents:
+2. Need more info / has uncertainties / multiple good resolutions exist: then repeatedly interview user with \`question\` tool by suggesting options until clear.
+3. Consider practical tasks (immediately possible) to complete assignment:
+    - Only 1 practical task to complete assignment: then tell user next task with emojis in Concise English (max 20 words) and then proceed with assignment.
+    - Multiple practical tasks possible: then call question tool with tasks as options
+4. Complete the assignment by tasking subagents:
     - Call \`todowrite\` tool to keep track of complex multi-step assignments
     - Repeatedly task subagents until assignment is completed or failed
-4. Summarize output of \`task\` tool in Concise English (max 40 words)
-5. Measure task results according against assignment:
+5. Summarize output of \`task\` tool in Concise English (max 40 words), except if code was written then respond with basic flow diagram in Mermaid syntax
+6. Measure task results according against assignment:
    - Failure: Follow [Troubleshooting Workflow](#troubleshooting)
    - Success, but assignment is incomplete:
         1. Report to user why assignment is incomplete and what is lacking
@@ -2599,7 +2620,7 @@ ${definitions}
 - You \`task\` subagent \`auto_troubleshoot\` to resolve obstacles.
 - You discover new CONSTRAINTS and RISKS as more info become available and alter acceptance criteria and PROPOSAL accordingly as long as original REQUIREMENTS are meet.
 - You evaluate your own work against original REQUIREMENTS (acceptance criteria) and NEVER stop until all REQUIREMENTS are met.
-- When planned solution is completed and evaluated, tell the user to accept it with \`/job-review\`; use \`/job-shelved\` only for closure without acceptance.
+- When planned solution is completed and evaluated, tell the user to accept it with \`/job-review\`; use \`/job-shelve\` only for closure without acceptance.
 
 ### User's Responsibilities
 
@@ -3973,9 +3994,9 @@ Read the instruction and determine what changes are requested, where, and if any
 
 ### Step 2: Load Skill
 
-For simple 1 line corrections that user specifically requested, just make the correction directly and report back to user in 1 sentence.
+For simple 1 line or small correction tasks user specifically requested, do direct targeted edit and skip skill loading.
 
-Unless the user specifically identified the markdown tone, format, and style, load the appropriate skill formatting rules (if not yet loaded).
+Load only skill that matches request (if not yet loaded).
 
 ### Step 3: Analyze Article
 
@@ -5630,7 +5651,7 @@ CONCEPT = a conceptual project improvement idea (like fixing bug, adding feature
 2. Create 1 CONCEPT per independent group of issues calling \`autocode_concept_create\` tool with formatted [Concept Parameter](#concept)
 3. Report CONCEPT labels and file paths.
 
-${swap2assistRule}
+${swap2previousRule}
 
 ## Concept Parameter {concept}
 
@@ -5739,7 +5760,7 @@ Rules:
 - Start H2 titles and bullet points with relevant emojis
 ${markdown}
 
-${swap2assistRule}
+${swap2previousRule}
 `;
 
 // src/agents/index.ts
@@ -5934,6 +5955,7 @@ var baseAgents = {
     mode: "primary",
     permission: {
       "*": "deny",
+      autocode_agent_execute: "allow",
       autocode_agent_swap: "allow",
       autocode_concept_list: "allow",
       autocode_concept_read: "allow",
@@ -6288,7 +6310,7 @@ var baseAgents = {
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow",
+      autocode_agent_previous: "allow",
       doom_loop: "deny",
       edit: "allow",
       glob: "allow",
@@ -6310,7 +6332,7 @@ var baseAgents = {
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow",
+      autocode_agent_previous: "allow",
       doom_loop: "deny",
       edit: "allow",
       glob: "allow",
@@ -6333,7 +6355,7 @@ var baseAgents = {
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow",
+      autocode_agent_previous: "allow",
       doom_loop: "deny",
       edit: "allow",
       glob: "allow",
@@ -6356,7 +6378,7 @@ var baseAgents = {
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow",
+      autocode_agent_previous: "allow",
       doom_loop: "deny",
       edit: "allow",
       glob: "allow",
@@ -6378,7 +6400,7 @@ var baseAgents = {
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow",
+      autocode_agent_previous: "allow",
       doom_loop: "deny",
       edit: "allow",
       glob: "allow",
@@ -6401,7 +6423,7 @@ var baseAgents = {
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow",
+      autocode_agent_previous: "allow",
       doom_loop: "deny",
       edit: "allow",
       glob: "allow",
@@ -6423,7 +6445,7 @@ var baseAgents = {
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow",
+      autocode_agent_previous: "allow",
       autocode_logo_find: "allow",
       doom_loop: "deny",
       edit: "allow",
@@ -6537,7 +6559,9 @@ var baseAgents = {
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow",
+      autocode_agent_previous: "allow",
+      autocode_criteria_list: "allow",
+      autocode_job_shelve: "allow",
       doom_loop: "deny",
       git_git_add: "allow",
       git_git_commit: "allow",
@@ -6809,26 +6833,13 @@ var baseAgents = {
     temperature: 0.5,
     tier: "fast"
   },
-  temp_agent: {
-    color: colorWritableWorker,
-    hidden: true,
-    mode: "subagent",
-    permission: {
-      "*": "deny",
-      autocode_agent_swap: "allow",
-      autocode_job_list: "allow",
-      autocode_plan_read: "allow"
-    },
-    prompt: "---",
-    temperature: 0.5,
-    tier: "fast"
-  },
   temp_concept: {
     color: colorWritableWorker,
     hidden: true,
     mode: "subagent",
     permission: {
       "*": "deny",
+      autocode_agent_previous: "allow",
       autocode_concept_create: "allow",
       skill: {
         "*": "deny",
@@ -6839,13 +6850,27 @@ var baseAgents = {
     prompt: tempConceptPrompt,
     tier: "fast"
   },
+  temp_execute: {
+    color: colorWritableWorker,
+    hidden: true,
+    mode: "subagent",
+    permission: {
+      "*": "deny",
+      autocode_agent_execute: "allow",
+      autocode_job_list: "allow",
+      question: "allow"
+    },
+    prompt: "---",
+    temperature: 0.5,
+    tier: "fast"
+  },
   temp_manual: {
     color: colorReadOnlyWorker,
     hidden: true,
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow"
+      autocode_agent_previous: "allow"
     },
     prompt: tempManualPrompt,
     temperature: 0.3,
@@ -6857,7 +6882,7 @@ var baseAgents = {
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow"
+      autocode_agent_previous: "allow"
     },
     prompt: tempReportPrompt,
     temperature: 0.3,
@@ -6869,12 +6894,24 @@ var baseAgents = {
     mode: "subagent",
     permission: {
       "*": "deny",
-      autocode_agent_swap: "allow",
+      autocode_agent_previous: "allow",
       autocode_session_create: "allow"
     },
     prompt: "---",
     temperature: 0.5,
     tier: "fast"
+  },
+  temp_shelve: {
+    color: colorWritableWorker,
+    hidden: true,
+    mode: "subagent",
+    permission: {
+      "*": "deny",
+      autocode_job_shelve: "allow"
+    },
+    prompt: "---",
+    temperature: 0.5,
+    tier: "fast"
   }
 };
 function buildAgents(externalDirectories = {}, sandboxSupportOverride) {
@@ -7120,37 +7157,79 @@ async function loadAutocodeConfig(worktree, directory, fs = defaultFs) {
   return { tiers, externalDirectories, sandbox };
 }
 
-// src/commands/index.ts
-function buildJobExecutionTemplate(agent) {
-  return `
-Call \`autocode_job_execute\` with \`agent\` = \`${agent}\`, then evaluate tool output:
-    - \`result_type == "draft_required"\`, then restart your Design Workflow without tasking other agents and draft a solution plan to execute.
-    - \`result_type == "no_plans"\`, then tell user there are no plans to execute and that he should run \`/job-draft\` command first to create a drafted solution plan in \`.agents/jobs/drafts/{name}/plan.md\`.
-    - \`result_type == "session_created"\`, then respond with:
+// src/commands/author_article.ts
+var authorArticleCommandTemplate = `$ARGUMENTS
 
-\`\`\`markdown
-Follow job at new session called: "[session_title]".
-\`\`\`
+_____________________________
 
-Replace [session_title] with \`session_title\` value from \`autocode_job_execute\` tool response.
+Apply \`author-article\` skill to edit user provided article.
+
+${swap2previousRule}
 `;
-}
-function buildNewSessionTemplate(agent, promptInstructions, responsePrefix) {
-  return `
-$ARGUMENTS
 
-__________
+// src/commands/document_code.ts
+var documentCodeCommandTemplate = `$ARGUMENTS
 
-1. Call \`autocode_session_create\` with \`agent\` = \`${agent}\` and \`prompt\` ${promptInstructions}
-2. Respond to user:
+${swap2previousRule}
+`;
 
-\`\`\`markdown
-${responsePrefix}: "[session_title]".
-\`\`\`
+// src/commands/document_conventions.ts
+var documentConventionsCommandTemplate = `$ARGUMENTS
 
-Replace [session_title] with \`session_title\` value from \`autocode_session_create\` tool response.
+${swap2previousRule}
 `;
-}
+
+// src/commands/document_prd.ts
+var documentPrdCommandTemplate = `$ARGUMENTS
+
+${swap2previousRule}
+`;
+
+// src/commands/document.ts
+var documentCommandTemplate = `
+1. Determine responsible subagents to document recent project changes: \`document_conventions\`, \`document_code\`, \`document_install\`, \`document_prd\`, \`document_ux\`
+2. Task responsible subagent with instruction to update their SKILL.md file with only relevant changes (include only related changes in prompt - must match subagent description).
+3. Collect subagent reports
+4. Update \`README.md\` using collected reports (only update applicable sections - not entire file)
+5. Only task \`document_agents\` *AFTER* you had updated \`README.md\` with prompt to check if any of recent changes are applicable to content in AGENTS.md (only update AGENTS.md if outdated)
+
+${swap2previousRule}
+`;
+
+// src/commands/document_ux.ts
+var documentUxCommandTemplate = `$ARGUMENTS
+
+${swap2previousRule}
+`;
+
+// src/commands/git_commit.ts
+var gitCommitCommandTemplate = `
+Base your git commit message on the following:
+  - Purpose of this session (see title)
+  - Your recent conversation with user
+  - Recent changes
+
+${swap2previousRule}
+`;
+
+// src/commands/git_conflict.ts
+var gitConflictCommandTemplate = `$ARGUMENTS
+
+${swap2previousRule}
+`;
+
+// src/commands/init.ts
+var initCommandTemplate = `
+1. Task subagents in parallel: \`document_conventions\`, \`document_code\`, \`document_install\`, \`document_prd\` 
+2. Additionally task \`document_ux\` for frontend/web projects
+3. Collect all subagent reports
+4. Use \`author-readme\` skill to update \`README.md\` using collected reports
+5. Only task \`document_agents\` *AFTER* you had updated \`README.md\` because \`document_agents\` will read your updated \`README.md\` file
+
+${swap2previousRule}
+`;
+
+// src/commands/install.ts
 var installCommand = {
   agent: "assist",
   description: "Install or remediate Autocode runtime dependencies.",
@@ -7170,21 +7249,15 @@ var installCommand = {
 12. After summary report, perform no next action, just stop.
 `
 };
-var commands = {
-  "job-concepts": {
-    agent: "temp_concept",
-    description: "Save concepts in .agents/jobs/concepts/.",
-    subtask: false,
-    template: `$ARGUMENTS
 
-${swap2assistRule}
-`
-  },
-  "job-design": {
-    agent: "design",
-    description: "Design a solution plan from a concept in .agents/jobs/concepts/",
-    subtask: false,
-    template: `$ARGUMENTS        
+// src/commands/job_concepts.ts
+var jobConceptsCommandTemplate = `$ARGUMENTS
+
+${swap2previousRule}
+`;
+
+// src/commands/job_design.ts
+var jobDesignCommandTemplate = `$ARGUMENTS        
 
 _____________________________
 
@@ -7195,13 +7268,10 @@ If you recently created a concept with \`autocode_concept_create\`, then use tha
 3. If concepts were listed, display available concept labels using \`question\` tool and ask "Which concept should we use to design an implementation plan?"
 4. Call \`autocode_concept_read\` with the selected concept \`label\` to read your INSTRUCTIONS.
 5. Continue implementation-proposal planning in the current session using the returned concept context and recent conversation.
-`
-  },
-  "job-draft": {
-    agent: "design",
-    description: "Save drafted solution plan in .agents/jobs/drafts/{name}/plan.md",
-    subtask: false,
-    template: `
+`;
+
+// src/commands/job_draft.ts
+var jobDraftCommandTemplate = `
 1. Call \`autocode_plan_save\` tool with planned sections: PROBLEMS, REQUIREMENTS, CONSTRAINTS, RISKS, and user chosen PROPOSAL.
 2. Respond with:
 
@@ -7223,139 +7293,260 @@ Replace [job_path] with \`job_path\` value from \`autocode_plan_save\` tool resp
 - Use emojis only to highlight important points.
 - Include markdown links to sources consulted.
 - Every constraints must be backed by evidence, assumptions are risks.
-`
+`;
+
+// src/commands/job_execute.ts
+var jobExecuteCommandTemplate = `
+1. Call \`autocode_job_list\` to list all available jobs.
+2. Call \`question\` once with exactly two batched questions:
+    - Choose one available job from \`autocode_job_list\` output.
+    - Choose execution agent: \`auto\` or \`assist\`.
+3. Call \`autocode_agent_execute\` once with selected \`job_name\` and selected \`agent\`, then evaluate tool output:
+    - If output includes \`failedAction\`, follow returned \`instruction\` exactly and stop.
+    - If output includes \`current_status\`, respond to user:
+
+\`\`\`markdown
+Continue job in [agent] session.
+\`\`\`
+
+Replace [agent] with selected execution agent.
+`;
+
+// src/commands/job_execution_template.ts
+function buildJobExecutionCommandTemplate(agent) {
+  return `
+Call \`autocode_job_execute\` with \`agent\` = \`${agent}\`, then evaluate tool output:
+    - If output includes \`failedAction\`, follow returned \`instruction\` exactly and stop.
+    - \`result_type == "draft_required"\`, then restart your Design Workflow without tasking other agents and draft a solution plan to execute.
+    - \`result_type == "no_plans"\`, then tell user there are no plans to execute and that they should run \`/job-draft\` first to create a drafted solution plan in \`.agents/jobs/drafts/{name}/plan.md\`.
+    - \`result_type == "session_created"\`, then respond with:
+
+\`\`\`markdown
+Follow job at new session called: "[session_title]".
+\`\`\`
+
+Replace [session_title] with \`session_title\` value from \`autocode_job_execute\` tool response.
+`;
+}
+
+// src/commands/job_execute_assist.ts
+var jobExecuteAssistCommandTemplate = buildJobExecutionCommandTemplate("assist");
+
+// src/commands/job_execute_auto.ts
+var jobExecuteAutoCommandTemplate = buildJobExecutionCommandTemplate("auto");
+
+// src/commands/job_review.ts
+var jobReviewCommandTemplate = `
+1. Call \`autocode_criteria_list\` tool, if output show any unmet criteria, then inform user about unmet criteria and stop.
+2. If this is git repo, then base your git commit message on plan of this job and Review Report.
+3. Lastly when done, call \`autocode_job_shelve\` to shelve accepted review, then stop.
+`;
+
+// src/commands/new_session_template.ts
+function buildNewSessionCommandTemplate(agent, promptInstructions, responsePrefix) {
+  return `
+$ARGUMENTS
+
+__________
+
+1. Call \`autocode_session_create\` with \`agent\` = \`${agent}\` and \`prompt\` ${promptInstructions}
+2. Respond to user:
+
+\`\`\`markdown
+${responsePrefix}: "[session_title]".
+\`\`\`
+
+Replace [session_title] with \`session_title\` value from \`autocode_session_create\` tool response.
+`;
+}
+
+// src/commands/new_assist.ts
+var newAssistCommandTemplate = buildNewSessionCommandTemplate("assist", `with recent user instructions to solve recently mentioned problem which includes:
+    - PROBLEMS = Brief background context and wrong/missing behavior/info (undesired symptoms)
+    - REQUIREMENTS = Expected system behavior / use case / answer to query
+    - CONSTRAINTS = research scope (domain) or fixed technical/legal limits (facts) like security measures, dependencies, performance limitations, maintainability limitations, failure handling, reversibility, etc.
+    - RISKS = any uncertainties (inaccessible/conflicting info), *assumed* limitations (edge-case concerns), external blockers (uncontrollable events/dependencies preventing solution), assumed caused of problem
+    - PROPOSAL = only include if user suggested a solution
+    - DATA = proof (all known paths/links to sources or facts), previous tool output, research results, exact values provided by user (do not repeat already included data)`, "Assist task execution session");
+
+// src/commands/new_auto.ts
+var newAutoCommandTemplate = buildNewSessionCommandTemplate("auto", `with recent user instructions to solve recently mentioned problem which includes:
+    - PROBLEMS = Brief background context and wrong/missing behavior/info (undesired symptoms)
+    - REQUIREMENTS = Expected system behavior / use case / answer to query
+    - CONSTRAINTS = research scope (domain) or fixed technical/legal limits (facts) like security measures, dependencies, performance limitations, maintainability limitations, failure handling, reversibility, etc.
+    - RISKS = any uncertainties (inaccessible/conflicting info), *assumed* limitations (edge-case concerns), external blockers (uncontrollable events/dependencies preventing solution), assumed caused of problem
+    - PROPOSAL = only include if user suggested a solution
+    - DATA = proof (all known paths/links to sources or facts), previous tool output, research results, exact values provided by user (do not repeat already included data)`, "Follow autonomous task execution session");
+
+// src/commands/new_design.ts
+var newDesignCommandTemplate = buildNewSessionCommandTemplate("design", `with instructions to design solution plan according based on:
+    - how: suggested cause of action
+    - what: expectation of new session
+    - why: brief background context
+    - context: all known facts related to instruction such as (past actions + its outcomes, failed attempts + reason for failure, constraints/opportunities discovered related to instruction)
+    - proof: all known paths/links to sources of facts
+    - data: previous tool output / research results / data provided by user (only include related to instruction; do not repeat already included data)`, "Advise design session");
+
+// src/commands/new_research.ts
+var newResearchCommandTemplate = buildNewSessionCommandTemplate("research", `with instructions to research topic based on:
+    - subject: name what info is required based on recent reasoning / user conversation
+    - context: include all known facts related to instruction such as (past actions + its outcomes, failed attempts + reason for failure, constraints/opportunities discovered related to instruction)
+    - proof: all known paths/links to sources of facts
+    - data: previous tool output / research results / data provided by user (only include related to instruction; do not repeat already included data)`, "Follow research session");
+
+// src/commands/new_troubleshoot.ts
+var newTroubleshootCommandTemplate = buildNewSessionCommandTemplate("assist_troubleshoot", `with instructions that include:
+    - SYMPTOMS = recently observed unexpected/wrong behavior 
+    - ENVIRONMENT = environment context where SYMPTOM occurs (like OS, runtime version, profile, config)
+    - BACKGROUND = why assignment is needed (if known)
+    - CHANGES = what you recently changed that might be relevant to obstacle
+    - EXPECTATION = what is expected to happen (like "respond 200 OK")
+    - CAUSE = what possibly caused SYMPTOM (like "new auth library is incorrectly implemented")
+    - EVIDENCE = facts that support theory of CAUSE (include blockcode of actual data, snippets of code, filenames, line numbers, urls, etc)
+    - ERROR = EVIDENCE observed facts about SYMPTOM (like specific error message, stack trace, or exception)
+    - TRACE = where ERROR was observed (like trace_id, log file, line number, timestamp, surrounding log messages, etc)
+    - REPRODUCTION = steps to reproduce SYMPTOM in ENVIRONMENT include sample input data in blockcode (if possible)`, "Follow troubleshoot session");
+
+// src/commands/repeat_as_md.ts
+var repeatAsMdCommandTemplate = `
+Repeat your last response wrapped in markdown codeblock:
+
+For example:
+
+\`\`\`\`\`\`\`\`\`markdown
+Last response goes here...
+\`\`\`\`\`\`\`\`\`        
+`;
+
+// src/commands/repeat_as_wiki.ts
+var repeatAsWikiCommandTemplate = `
+Repeat your last response as Markdown block text in Atlassian Wiki Markup (Jira Wiki syntax) format:
+
+For example:
+
+\`\`\`\`\`\`\`\`\`markdown
+Wiki markup goes here...
+\`\`\`\`\`\`\`\`\`        
+`;
+
+// src/commands/report_last.ts
+var reportLastCommandTemplate = `
+Report **ONLY** on your last assignment (last user requested task). Include only last user prompt, recent actions since last user prompt and recent tool outputs into consideration when you compile the report.
+
+${swap2previousRule}
+`;
+
+// src/commands/report_session.ts
+var reportSessionCommandTemplate = `
+Report on entire session taking all actions, tool outputs and prompts in consideration.
+
+${swap2previousRule}
+`;
+
+// src/commands/index.ts
+var shelveCommandTemplate = "Call `autocode_job_shelve` to shelve job into `.agents/jobs/shelved/{name}/`, then stop.";
+var commands = {
+  "job-concepts": {
+    agent: "temp_concept",
+    description: "Save concepts in .agents/jobs/concepts/.",
+    subtask: false,
+    template: jobConceptsCommandTemplate
+  },
+  "job-design": {
+    agent: "design",
+    description: "Design a solution plan from a concept in .agents/jobs/concepts/",
+    subtask: false,
+    template: jobDesignCommandTemplate
+  },
+  "job-draft": {
+    agent: "design",
+    description: "Save drafted solution plan in .agents/jobs/drafts/{name}/plan.md",
+    subtask: false,
+    template: jobDraftCommandTemplate
   },
   "job-execute-assist": {
     agent: "design",
     description: "Assist with job execution in new session. Job will move to .agents/jobs/assist/{name}/.",
     subtask: false,
-    template: buildJobExecutionTemplate("assist")
+    template: jobExecuteAssistCommandTemplate
   },
   "job-execute-auto": {
     agent: "design",
     description: "Execute job autonomously in new session and move job to .agents/jobs/executing/{name}/",
     subtask: false,
-    template: buildJobExecutionTemplate("auto")
+    template: jobExecuteAutoCommandTemplate
   },
   "job-execute": {
-    agent: "temp_agent",
+    agent: "temp_execute",
     description: "Select and execute job in the current session.",
     subtask: false,
-    template: `
-1. Call \`autocode_job_list\` to list all available jobs.
-2. Call \`question\` once with exactly two batched questions:
-    - Choose one available job from \`autocode_job_list\` output.
-    - Choose execution agent: \`auto\` or \`assist\`.
-3. Call \`autocode_plan_read\` with selected \`job_name\` to read the selected job plan.
-4. Call \`autocode_agent_swap\` with \`agent\` set to the selected agent.
-`
+    template: jobExecuteCommandTemplate
   },
   "job-review": {
-    agent: "auto",
+    agent: "execute_git_commit",
     description: "Commit accepted work and shelve into .agents/jobs/shelved/{name}/",
     subtask: false,
-    template: `
-1. Call \`autocode_criteria_list\` tool, if output show any unmet criteria, then inform user about unmet criteria and stop.
-2. If this is git repo, then base your git commit message on plan of this job and Review Report.
-3. Lastly when done, call \`autocode_shelve\` to shelve accepted review into \`.agents/jobs/shelved/{name}/\`, then stop.
-`
+    template: jobReviewCommandTemplate
   },
-  "job-shelved": {
-    agent: "auto",
+  "job-shelve": {
+    agent: "temp_shelve",
     description: "Shelve current job and move job to .agents/jobs/shelved/{name}/",
     subtask: false,
-    template: "Call `autocode_shelve` to shelve job into `.agents/jobs/shelved/{name}/`, then stop."
+    template: shelveCommandTemplate
   },
   shelve: {
-    agent: "auto",
+    agent: "temp_shelve",
     description: "Shelve current job and move job to .agents/jobs/shelved/{name}/",
     subtask: false,
-    template: "Call `autocode_shelve` to shelve job into `.agents/jobs/shelved/{name}/`, then stop."
+    template: shelveCommandTemplate
   },
   "author-article": {
     agent: "execute_author",
     description: "Author a professional article/report.",
     subtask: false,
-    template: `$ARGUMENTS
-
-_____________________________
-
-Apply \`author-article\` skill to edit user provided article.
-
-${swap2assistRule}
-`
+    template: authorArticleCommandTemplate
   },
   document: {
     agent: "document",
     description: "Document recent project changes.",
     subtask: false,
-    template: `
-1. Determine responsible subagents to document recent project changes: \`document_conventions\`, \`document_code\`, \`document_install\`, \`document_prd\`, \`document_ux\`
-2. Task responsible subagent with instruction to update their SKILL.md file with only relevant changes (include only related changes in prompt - must match subagent description).
-3. Collect subagent reports
-4. Update \`README.md\` using collected reports (only update applicable sections - not entire file)
-5. Only task \`document_agents\` *AFTER* you had updated \`README.md\` with prompt to check if any of recent changes are applicable to content in AGENTS.md (only update AGENTS.md if outdated)
-
-${swap2assistRule}
-`
+    template: documentCommandTemplate
   },
   "document-conventions": {
     agent: "document_conventions",
     description: "Document recently updated naming conventions and terminology.",
     subtask: false,
-    template: `$ARGUMENTS
-
-${swap2assistRule}
-`
+    template: documentConventionsCommandTemplate
   },
   "document-code": {
     agent: "document_code",
     description: "Document recently updated technical architecture and design decisions.",
     subtask: false,
-    template: `$ARGUMENTS
-
-${swap2assistRule}
-`
+    template: documentCodeCommandTemplate
   },
   "document-prd": {
     agent: "document_prd",
     description: "Document recently updated product requirements and user roles.",
     subtask: false,
-    template: `$ARGUMENTS
-
-${swap2assistRule}
-`
+    template: documentPrdCommandTemplate
   },
   "document-ux": {
     agent: "document_ux",
     description: "Document recently updated UX flows, navigation, and styling patterns.",
     subtask: false,
-    template: `$ARGUMENTS
-
-${swap2assistRule}
-`
+    template: documentUxCommandTemplate
   },
   "git-commit": {
     agent: "execute_git_commit",
     description: "Automatically commit staged changes.",
     subtask: false,
-    template: `
-Base your git commit message on the following:
-  - Purpose of this session (see title)
-  - Your recent conversation with user
-  - Recent changes
-
-${swap2assistRule}
-`
+    template: gitCommitCommandTemplate
   },
   "git-conflict": {
     agent: "assist_git_conflict",
     description: "Automatically handle git merge conflicts.",
     subtask: false,
-    template: `$ARGUMENTS
-
-${swap2assistRule}
-`
+    template: gitConflictCommandTemplate
   },
   install: installCommand,
   "autocode-install": installCommand,
@@ -7363,123 +7554,59 @@ ${swap2assistRule}
     agent: "execute_document",
     description: "Document the entire project.",
     subtask: true,
-    template: `
-1. Task subagents in parallel: \`document_conventions\`, \`document_code\`, \`document_install\`, \`document_prd\` 
-2. Additionally task \`document_ux\` for frontend/web projects
-3. Collect all subagent reports
-4. Use \`author-readme\` skill to update \`README.md\` using collected reports
-5. Only task \`document_agents\` *AFTER* you had updated \`README.md\` because \`document_agents\` will read your updated \`README.md\` file
-
-${swap2assistRule}
-`
+    template: initCommandTemplate
   },
   "new-assist": {
     agent: "temp_session",
     description: "Assist task execution in new session.",
     subtask: false,
-    template: buildNewSessionTemplate("assist", `with recent user instructions to solve recently mentioned problem which includes:
-    - PROBLEMS = Brief background context and wrong/missing behavior/info (undesired symptoms)
-    - REQUIREMENTS = Expected system behavior / use case / answer to query
-    - CONSTRAINTS = research scope (domain) or fixed technical/legal limits (facts) like security measures, dependencies, performance limitations, maintainability limitations, failure handling, reversibility, etc.
-    - RISKS = any uncertainties (inaccessible/conflicting info), *assumed* limitations (edge-case concerns), external blockers (uncontrollable events/dependencies preventing solution), assumed caused of problem
-    - PROPOSAL = only include if user suggested a solution
-    - DATA = proof (all known paths/links to sources or facts), previous tool output, research results, exact values provided by user (do not repeat already included data)`, "Assist task execution session")
+    template: newAssistCommandTemplate
   },
   "new-auto": {
     agent: "temp_session",
     description: "Autonomously execute task in new session.",
     subtask: false,
-    template: buildNewSessionTemplate("auto", `with recent user instructions to solve recently mentioned problem which includes:
-    - PROBLEMS = Brief background context and wrong/missing behavior/info (undesired symptoms)
-    - REQUIREMENTS = Expected system behavior / use case / answer to query
-    - CONSTRAINTS = research scope (domain) or fixed technical/legal limits (facts) like security measures, dependencies, performance limitations, maintainability limitations, failure handling, reversibility, etc.
-    - RISKS = any uncertainties (inaccessible/conflicting info), *assumed* limitations (edge-case concerns), external blockers (uncontrollable events/dependencies preventing solution), assumed caused of problem
-    - PROPOSAL = only include if user suggested a solution
-    - DATA = proof (all known paths/links to sources or facts), previous tool output, research results, exact values provided by user (do not repeat already included data)`, "Follow autonomous task execution session")
+    template: newAutoCommandTemplate
   },
   "new-design": {
     agent: "temp_session",
     description: "Design solutions in new session.",
     subtask: false,
-    template: buildNewSessionTemplate("design", `with instructions to design solution plan according based on:
-    - how: suggested cause of action
-    - what: expectation of new session
-    - why: brief background context
-    - context: all known facts related to instruction such as (past actions + its outcomes, failed attempts + reason for failure, constraints/opportunities discovered related to instruction)
-    - proof: all known paths/links to sources of facts
-    - data: previous tool output / research results / data provided by user (only include related to instruction; do not repeat already included data)`, "Advise design session")
+    template: newDesignCommandTemplate
   },
   "new-research": {
     agent: "temp_session",
     description: "Research topic in new session that produces a research report.",
     subtask: false,
-    template: buildNewSessionTemplate("research", `with instructions to research topic based on:
-    - subject: name what info is required based on recent reasoning / user conversation
-    - context: include all known facts related to instruction such as (past actions + its outcomes, failed attempts + reason for failure, constraints/opportunities discovered related to instruction)
-    - proof: all known paths/links to sources of facts
-    - data: previous tool output / research results / data provided by user (only include related to instruction; do not repeat already included data)`, "Follow research session")
+    template: newResearchCommandTemplate
   },
   "new-troubleshoot": {
     agent: "temp_session",
     description: "Troubleshoot issue in new session.",
     subtask: false,
-    template: buildNewSessionTemplate("assist_troubleshoot", `with instructions that include:
-    - SYMPTOMS = recently observed unexpected/wrong behavior 
-    - ENVIRONMENT = environment context where SYMPTOM occurs (like OS, runtime version, profile, config)
-    - BACKGROUND = why assignment is needed (if known)
-    - CHANGES = what you recently changed that might be relevant to obstacle
-    - EXPECTATION = what is expected to happen (like "respond 200 OK")
-    - CAUSE = what possibly caused SYMPTOM (like "new auth library is incorrectly implemented")
-    - EVIDENCE = facts that support theory of CAUSE (include blockcode of actual data, snippets of code, filenames, line numbers, urls, etc)
-    - ERROR = EVIDENCE observed facts about SYMPTOM (like specific error message, stack trace, or exception)
-    - TRACE = where ERROR was observed (like trace_id, log file, line number, timestamp, surrounding log messages, etc)
-    - REPRODUCTION = steps to reproduce SYMPTOM in ENVIRONMENT include sample input data in blockcode (if possible)`, "Follow troubleshoot session")
+    template: newTroubleshootCommandTemplate
   },
   "repeat-as-md": {
     description: "Repeat the last response inside a fenced Markdown code block.",
     subtask: false,
-    template: `
-Repeat your last response wrapped in markdown codeblock:
-
-For example:
-
-\`\`\`\`\`\`\`\`\`markdown
-Last response goes here...
-\`\`\`\`\`\`\`\`\`        
-`
+    template: repeatAsMdCommandTemplate
   },
   "repeat-as-wiki": {
     description: "Repeat last response in Atlassian Wiki Markup",
     subtask: false,
-    template: `
-Repeat your last response as Markdown block text in Atlassian Wiki Markup (Jira Wiki syntax) format:
-
-For example:
-
-\`\`\`\`\`\`\`\`\`markdown
-Wiki markup goes here...
-\`\`\`\`\`\`\`\`\`        
-`
+    template: repeatAsWikiCommandTemplate
   },
   "report-last": {
     agent: "temp_report",
     description: "Provide detailed report of last task.",
     subtask: false,
-    template: `
-Report **ONLY** on your last assignment (last user requested task). Include only last user prompt, recent actions since last user prompt and recent tool outputs into consideration when you compile the report.
-
-${swap2assistRule}
-`
+    template: reportLastCommandTemplate
   },
   "report-session": {
     agent: "temp_report",
     description: "Provide detailed report of entire session.",
     subtask: false,
-    template: `
-Report on entire session taking all actions, tool outputs and prompts in consideration.
-
-${swap2assistRule}
-`
+    template: reportSessionCommandTemplate
   },
   resume: {
     description: "Resume interrupted session.",
@@ -19906,6 +20033,9 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
+// src/tools/autocode_agent_execute.ts
+import { mkdir as mkdir4, readFile as readFile3, readdir as readdir4, rename as rename3, rm as rm4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
+
 // src/utils/tools.ts
 var retryCounts = new Map;
 function sortValue(value, seen = new WeakSet) {
@@ -19980,6 +20110,7 @@ function createLifecycleJobRequiredRetryResponse(failedAction, subject) {
 }
 
 // src/utils/agent_swap.ts
+var primaryAutocodeAgents = ["assist", "auto", "design", "research"];
 var allowedAutocodeSessionCreateAgents = ["assist", "auto", "research", "design"];
 var allowedAutocodeSessionCreateAgentsText = allowedAutocodeSessionCreateAgents.join(", ");
 function isNonBlankString(value) {
@@ -20003,6 +20134,15 @@ function unwrapOpenCodeError(response) {
 function resolveAutocodeAgentSessionTier(agent) {
   return getAgentTier(agent);
 }
+function isPrimaryAutocodeAgent(agent) {
+  return typeof agent === "string" && primaryAutocodeAgents.includes(agent);
+}
+function getMessageCreatedTime(message) {
+  return message.info.time.created;
+}
+function getMessageAgent(message) {
+  return message.info.agent;
+}
 function resolveTierModel(tier, tiers) {
   if (!tier) {
     return {};
@@ -20147,10 +20287,220 @@ function createAutocodeAgentSwapSuccessResponse(agent, sessionID) {
     message
   });
 }
+function createAutocodeAgentPreviousSkippedResponse(sessionID, reason) {
+  const message = `Skipped previous-primary handoff for current session (${sessionID}): ${reason}`;
+  return JSON.stringify({
+    session_id: sessionID,
+    skipped: true,
+    reason,
+    message
+  });
+}
+async function findPreviousPrimaryAutocodeAgent(client, directory, sessionID, currentAgent) {
+  if (!client.session.messages) {
+    return {
+      error: "Unable to inspect current session history: session.messages is unavailable",
+      instruction: ""
+    };
+  }
+  let response;
+  try {
+    response = await client.session.messages({
+      path: { id: sessionID },
+      query: {
+        directory,
+        limit: 200
+      }
+    });
+  } catch (error45) {
+    return {
+      error: createAutocodeSessionError("session_messages", directory, sessionID, currentAgent ?? "unknown", error45),
+      instruction: ""
+    };
+  }
+  const responseError = unwrapOpenCodeError(response);
+  if (responseError) {
+    return {
+      error: createAutocodeSessionError("session_messages", directory, sessionID, currentAgent ?? "unknown", responseError),
+      instruction: ""
+    };
+  }
+  const responseData = unwrapOpenCodeData(response) ?? [];
+  const sortedMessages = [...responseData].sort((left, right) => getMessageCreatedTime(right) - getMessageCreatedTime(left));
+  for (const message of sortedMessages) {
+    const agent = getMessageAgent(message);
+    if (!isPrimaryAutocodeAgent(agent)) {
+      continue;
+    }
+    if (isPrimaryAutocodeAgent(currentAgent) && agent === currentAgent) {
+      continue;
+    }
+    return {
+      agent,
+      skipped: false
+    };
+  }
+  return {
+    skipped: true,
+    reason: "No previous primary agent found in current session history."
+  };
+}
 async function swapCurrentAutocodeSession(client, directory, sessionID, agent, prompt, resolvedModel = {}) {
   return dispatchAutocodeAgentPrompt(client, directory, sessionID, agent, prompt, resolvedModel);
 }
 
+// src/tools/autocode_agent_execute.ts
+async function readDirectory3(dirPath, options) {
+  return options?.withFileTypes ? readdir4(dirPath, { withFileTypes: true }) : readdir4(dirPath);
+}
+var defaultFileSystem = {
+  mkdir: mkdir4,
+  readFile: readFile3,
+  readdir: readDirectory3,
+  rename: rename3,
+  rm: rm4,
+  stat: stat3,
+  writeFile: writeFile4
+};
+function isExecutionAgent(agent) {
+  return agent === "assist" || agent === "auto";
+}
+function getTargetStatus(agent, _currentStatus) {
+  return agent === "assist" ? "assist" : "executing";
+}
+function createAgentExecutePrompt(jobName, plan) {
+  return `Selected job: ${jobName}
+
+plan.md:
+${plan}`;
+}
+function createMissingJobRetryResponse(jobName) {
+  return createRetryResponse("autocode_agent_execute", `Planned job not found: ${jobName}`, "Provide job_name from an existing lifecycle job under .agents/jobs/.");
+}
+function createCollisionRetryResponse(jobName) {
+  return createRetryResponse("autocode_agent_execute", `Active lifecycle collision for ${jobName}`, "Resolve duplicate active lifecycle directories for this job before retrying.");
+}
+function createDestinationCollisionRetryResponse(jobName, status) {
+  return createRetryResponse("autocode_agent_execute", `${status} lifecycle directory already exists for ${jobName}`, `Resolve the existing .agents/jobs/${status}/ job collision before retrying.`);
+}
+function createMissingPlanRetryResponse(jobName) {
+  return createRetryResponse("autocode_agent_execute", `Plan not found for job: ${jobName}`, "Restore plan.md under the selected job lifecycle directory before retrying.");
+}
+function createReviewStatusRetryResponse(jobName) {
+  return createRetryResponse("autocode_agent_execute", `Selected job already in review: ${jobName}`, "Select job outside review before retrying autocode_agent_execute.");
+}
+function createAutocodeAgentExecuteTool(client, fileSystem = defaultFileSystem) {
+  return tool({
+    description: "Move selected job to execution status and swap current session to selected agent with plan.md injected.",
+    args: {
+      job_name: tool.schema.string().describe("Selected planned job_name in safe snake_case."),
+      agent: tool.schema.string().describe("Execution agent: assist or auto.")
+    },
+    async execute(args, context) {
+      const requestedJobName = args.job_name?.trim();
+      if (!requestedJobName || !isCompatibleJobName(requestedJobName)) {
+        return createRetryResponse("autocode_agent_execute", `Invalid job_name: ${requestedJobName ?? String(args.job_name)}`, "Provide a safe snake_case job_name containing only lowercase letters, numbers, and underscores.");
+      }
+      if (!isExecutionAgent(args.agent)) {
+        return createRetryResponse("autocode_agent_execute", `Invalid agent: ${args.agent}`, "Provide agent as one of: assist, auto.");
+      }
+      if (!client) {
+        return createAbortResponse("autocode_agent_execute", "Unable to swap current session: client is unavailable");
+      }
+      try {
+        const storageRoot = resolveAgentsStorageRoot(context);
+        const directoryFileSystem = createDirectoryFileSystem(fileSystem);
+        const resolved = await resolvePlannedJob(directoryFileSystem, storageRoot, requestedJobName);
+        if (resolved.type === "missing") {
+          return createMissingJobRetryResponse(requestedJobName);
+        }
+        if (resolved.type === "collision") {
+          return createCollisionRetryResponse(requestedJobName);
+        }
+        if (resolved.job.status === "review") {
+          return createReviewStatusRetryResponse(requestedJobName);
+        }
+        const planPath = getJobFilePath(storageRoot, resolved.job.directory, resolved.job.job_name, "plan.md");
+        let plan;
+        try {
+          plan = await fileSystem.readFile(planPath, "utf8");
+        } catch (error45) {
+          const code = error45.code;
+          if (code === "ENOENT") {
+            return createMissingPlanRetryResponse(requestedJobName);
+          }
+          throw error45;
+        }
+        if (!directoryFileSystem.rename) {
+          return createAbortResponse("autocode_agent_execute", "Unable to update selected job lifecycle: rename is unavailable");
+        }
+        const targetStatus = getTargetStatus(args.agent, resolved.job.status);
+        const moveFileSystem = {
+          ...directoryFileSystem,
+          rename: directoryFileSystem.rename
+        };
+        const moved = await moveResolvedPlannedJobToStatus(storageRoot, resolved.job, targetStatus, moveFileSystem);
+        if (moved.type === "missing") {
+          return createMissingJobRetryResponse(requestedJobName);
+        }
+        if (moved.type === "collision") {
+          return createCollisionRetryResponse(requestedJobName);
+        }
+        if (moved.type === "destination_collision") {
+          return createDestinationCollisionRetryResponse(requestedJobName, targetStatus);
+        }
+        const sessionSettings = await resolveAutocodeAgentSessionSettings(args.agent, context.worktree, context.directory);
+        if ("error" in sessionSettings) {
+          return createAbortResponse("autocode_agent_execute", sessionSettings.error);
+        }
+        const handoff = await swapCurrentAutocodeSession(client, context.directory, context.sessionID, args.agent, createAgentExecutePrompt(moved.job.job_name, plan), sessionSettings.resolvedModel);
+        if ("error" in handoff) {
+          return createAbortResponse("autocode_agent_execute", handoff.error);
+        }
+        return JSON.stringify({
+          current_status: moved.job.status
+        });
+      } catch (error45) {
+        return createAbortResponse("autocode_agent_execute", error45);
+      }
+    }
+  });
+}
+
+// src/tools/autocode_agent_previous.ts
+function createAutocodeAgentPreviousTool(client) {
+  return tool({
+    description: "Swap agent back to previous primary agent.",
+    args: {},
+    async execute(_args, context) {
+      if (!client) {
+        return createAbortResponse("autocode_agent_previous", "Unable to inspect current session history: client is unavailable");
+      }
+      try {
+        const currentAgent = context.agent;
+        const previousPrimary = await findPreviousPrimaryAutocodeAgent(client, context.directory, context.sessionID, currentAgent);
+        if ("error" in previousPrimary) {
+          return createAbortResponse("autocode_agent_previous", previousPrimary.error);
+        }
+        if (previousPrimary.skipped || !previousPrimary.agent) {
+          return createAutocodeAgentPreviousSkippedResponse(context.sessionID, previousPrimary.reason ?? "No previous primary agent found in current session history.");
+        }
+        const sessionSettings = await resolveAutocodeAgentSessionSettings(previousPrimary.agent, context.worktree, context.directory);
+        if ("error" in sessionSettings) {
+          return createAbortResponse("autocode_agent_previous", sessionSettings.error);
+        }
+        const handoff = await swapCurrentAutocodeSession(client, context.directory, context.sessionID, previousPrimary.agent, "Ask user for Next Action.", sessionSettings.resolvedModel);
+        if ("error" in handoff) {
+          return createAbortResponse("autocode_agent_previous", handoff.error);
+        }
+        return createAutocodeAgentSwapSuccessResponse(previousPrimary.agent, handoff.sessionID);
+      } catch (error45) {
+        return createAbortResponse("autocode_agent_previous", error45);
+      }
+    }
+  });
+}
+
 // src/tools/autocode_agent_swap.ts
 function createAutocodeAgentSwapTool(client) {
   return tool({
@@ -20185,12 +20535,12 @@ function createAutocodeAgentSwapTool(client) {
 }
 
 // src/tools/autocode_concept_create.ts
-import { mkdir as mkdir4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, stat as stat4, writeFile as writeFile5 } from "fs/promises";
 import path5 from "path";
-var defaultFileSystem = {
-  mkdir: mkdir4,
-  stat: stat3,
-  writeFile: writeFile4
+var defaultFileSystem2 = {
+  mkdir: mkdir5,
+  stat: stat4,
+  writeFile: writeFile5
 };
 function formatLocalTimestamp(date5) {
   const pad = (value) => String(value).padStart(2, "0");
@@ -20233,7 +20583,7 @@ async function resolveAvailableBacklogPath(fileSystem, worktree, baseLabel) {
   }
   throw new Error(`Unable to allocate backlog path for ${baseLabel}`);
 }
-function createAutocodeConceptCreateTool(client, fileSystem = defaultFileSystem, getNow = () => new Date) {
+function createAutocodeConceptCreateTool(client, fileSystem = defaultFileSystem2, getNow = () => new Date) {
   return tool({
     description: "Create one concept Markdown file in .agents/jobs/concepts/ from a title or label and raw Markdown body.",
     args: {
@@ -20279,11 +20629,11 @@ ${args.concept}`);
 }
 
 // src/tools/autocode_concept_list.ts
-import { readFile as readFile3, readdir as readdir4 } from "fs/promises";
+import { readFile as readFile4, readdir as readdir5 } from "fs/promises";
 import path6 from "path";
-var defaultFileSystem2 = {
-  readdir: readdir4,
-  readFile: readFile3
+var defaultFileSystem3 = {
+  readdir: readdir5,
+  readFile: readFile4
 };
 function getDescription(source) {
   const line = stripLeadingYamlFrontMatter(source).split(/\r?\n/).map((line2) => line2.trim()).find((line2) => !/^#{1,6}\s+/.test(line2) && /[a-z0-9]/i.test(line2)) ?? "";
@@ -20298,7 +20648,7 @@ async function readDirectoryEntries3(fileSystem, directory) {
     throw error45;
   }
 }
-function createAutocodeConceptListTool(fileSystem = defaultFileSystem2) {
+function createAutocodeConceptListTool(fileSystem = defaultFileSystem3) {
   return tool({
     description: "List available concepts.",
     args: {},
@@ -20322,13 +20672,13 @@ function createAutocodeConceptListTool(fileSystem = defaultFileSystem2) {
 }
 
 // src/tools/autocode_concept_read.ts
-import { mkdir as mkdir5, readFile as readFile4, rename as rename3, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile5, rename as rename4, writeFile as writeFile6 } from "fs/promises";
 import path7 from "path";
-var defaultFileSystem3 = {
-  mkdir: mkdir5,
-  readFile: readFile4,
-  rename: rename3,
-  writeFile: writeFile5
+var defaultFileSystem4 = {
+  mkdir: mkdir6,
+  readFile: readFile5,
+  rename: rename4,
+  writeFile: writeFile6
 };
 function getBacklogPath(worktree, label) {
   return path7.join(worktree, getRelativeConceptFilePath(label));
@@ -20343,7 +20693,7 @@ function normalizeConceptReadToolArgs(clientOrFileSystem, maybeFileSystem) {
   if (isFileSystem(clientOrFileSystem)) {
     return { fileSystem: clientOrFileSystem };
   }
-  return { client: clientOrFileSystem, fileSystem: defaultFileSystem3 };
+  return { client: clientOrFileSystem, fileSystem: defaultFileSystem4 };
 }
 function createAutocodeConceptReadTool(clientOrFileSystem, maybeFileSystem) {
   const { client, fileSystem } = normalizeConceptReadToolArgs(clientOrFileSystem, maybeFileSystem);
@@ -20381,12 +20731,12 @@ function createAutocodeConceptReadTool(clientOrFileSystem, maybeFileSystem) {
 }
 
 // src/tools/autocode_criteria.ts
-import { appendFile, mkdir as mkdir6, readFile as readFile5, readdir as readdir5, writeFile as writeFile6 } from "fs/promises";
+import { appendFile, mkdir as mkdir7, readFile as readFile6, readdir as readdir6, writeFile as writeFile7 } from "fs/promises";
 async function readDirectoryEntries4(dirPath, options) {
-  return readdir5(dirPath, options);
+  return readdir6(dirPath, options);
 }
-async function readDirectory3(dirPath, options) {
-  return options?.withFileTypes ? readdir5(dirPath, { withFileTypes: true }) : readdir5(dirPath);
+async function readDirectory4(dirPath, options) {
+  return options?.withFileTypes ? readdir6(dirPath, { withFileTypes: true }) : readdir6(dirPath);
 }
 function createResolveJobFileSystem(fileSystem) {
   return {
@@ -20397,12 +20747,12 @@ function createResolveJobFileSystem(fileSystem) {
     }
   };
 }
-var defaultFileSystem4 = {
+var defaultFileSystem5 = {
   appendFile,
-  mkdir: mkdir6,
-  readFile: readFile5,
-  readdir: readDirectory3,
-  writeFile: writeFile6
+  mkdir: mkdir7,
+  readFile: readFile6,
+  readdir: readDirectory4,
+  writeFile: writeFile7
 };
 function isPlannedJobNotFoundError(error45) {
   return error45.message?.startsWith("Planned job not found:") ?? false;
@@ -20455,7 +20805,7 @@ function normalizeCriteriaToolArgs(clientOrFileSystem, maybeFileSystem) {
   if (candidate && "readFile" in candidate && "writeFile" in candidate) {
     return { fileSystem: candidate };
   }
-  return { client: candidate, fileSystem: defaultFileSystem4 };
+  return { client: candidate, fileSystem: defaultFileSystem5 };
 }
 async function resolveCriteriaJobName(client, fileSystem, context, failedAction, options = {}) {
   const identity = await resolvePlannedJobIdentity(createResolveJobFileSystem(fileSystem), client, context, "");
@@ -22085,18 +22435,18 @@ function createAutocodeDependenciesTool(deps = defaultSandboxDependencies) {
 }
 
 // src/tools/autocode_job_execute.ts
-import { mkdir as mkdir7, readFile as readFile6, readdir as readdir6, rename as rename4, rm as rm4, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-async function readDirectory4(dirPath, options) {
-  return options?.withFileTypes ? readdir6(dirPath, { withFileTypes: true }) : readdir6(dirPath);
+import { mkdir as mkdir8, readFile as readFile7, readdir as readdir7, rename as rename5, rm as rm5, stat as stat5, writeFile as writeFile8 } from "fs/promises";
+async function readDirectory5(dirPath, options) {
+  return options?.withFileTypes ? readdir7(dirPath, { withFileTypes: true }) : readdir7(dirPath);
 }
-var defaultFileSystem5 = {
-  mkdir: mkdir7,
-  readFile: readFile6,
-  readdir: readDirectory4,
-  rename: rename4,
-  rm: rm4,
-  stat: stat4,
-  writeFile: writeFile7
+var defaultFileSystem6 = {
+  mkdir: mkdir8,
+  readFile: readFile7,
+  readdir: readDirectory5,
+  rename: rename5,
+  rm: rm5,
+  stat: stat5,
+  writeFile: writeFile8
 };
 function createStartRetryResponse(result, jobName, status) {
   if (result.type === "missing") {
@@ -22116,7 +22466,7 @@ function getExecutionStatus(agent, currentStatus) {
   }
   return currentStatus === "review" ? "review" : "executing";
 }
-function isExecutionAgent(agent) {
+function isExecutionAgent2(agent) {
   return agent === "auto" || agent === "assist";
 }
 async function persistJobSessionID(fileSystem, worktree, job, jobName, sessionID) {
@@ -22150,7 +22500,7 @@ async function hasExistingSession(client, directory, sessionID) {
     return false;
   }
 }
-function createAutocodeJobExecuteTool(client, fileSystem = defaultFileSystem5) {
+function createAutocodeJobExecuteTool(client, fileSystem = defaultFileSystem6) {
   return tool({
     description: "Execute job.",
     args: {
@@ -22158,7 +22508,7 @@ function createAutocodeJobExecuteTool(client, fileSystem = defaultFileSystem5) {
     },
     async execute(args, context) {
       try {
-        if (!isExecutionAgent(args.agent)) {
+        if (!isExecutionAgent2(args.agent)) {
           return createRetryResponse("autocode_job_execute", `Invalid agent: ${args.agent}`, "Provide agent as one of: auto, assist.");
         }
         const storageRoot = resolveAgentsStorageRoot(context);
@@ -22246,13 +22596,13 @@ function createAutocodeJobExecuteTool(client, fileSystem = defaultFileSystem5) {
 }
 
 // src/tools/autocode_job_list.ts
-import { readFile as readFile7, readdir as readdir7 } from "fs/promises";
-async function readDirectory5(dirPath, options) {
-  return options?.withFileTypes ? readdir7(dirPath, { withFileTypes: true }) : readdir7(dirPath);
+import { readFile as readFile8, readdir as readdir8 } from "fs/promises";
+async function readDirectory6(dirPath, options) {
+  return options?.withFileTypes ? readdir8(dirPath, { withFileTypes: true }) : readdir8(dirPath);
 }
-var defaultFileSystem6 = {
-  readFile: readFile7,
-  readdir: readDirectory5
+var defaultFileSystem7 = {
+  readFile: readFile8,
+  readdir: readDirectory6
 };
 async function executePlannedJobList(fileSystem, worktree, options) {
   try {
@@ -22267,7 +22617,7 @@ async function executePlannedJobList(fileSystem, worktree, options) {
     return createAbortResponse(options.failedAction, error45);
   }
 }
-function createAutocodeJobListTool(fileSystem = defaultFileSystem6) {
+function createAutocodeJobListTool(fileSystem = defaultFileSystem7) {
   return tool({
     description: "List active drafts/jobs.",
     args: {
@@ -22288,47 +22638,169 @@ function createAutocodeJobListTool(fileSystem = defaultFileSystem6) {
   });
 }
 
-// src/tools/autocode_job_status.ts
-import { mkdir as mkdir8, readFile as readFile8, readdir as readdir8, rename as rename5, rm as rm5, stat as stat5, writeFile as writeFile8 } from "fs/promises";
+// src/tools/autocode_job_shelve.ts
+import { mkdir as mkdir9, readFile as readFile9, readdir as readdir9, rename as rename6, rm as rm6, stat as stat6, writeFile as writeFile9 } from "fs/promises";
 
 // src/utils/shelve.ts
 async function shelveResolvedPlannedJob(options) {
-  const moved = await moveResolvedPlannedJobToStatus(options.storageRoot, options.resolvedJob, "shelved", options.moveFileSystem);
+  const timestamp = options.now();
+  const moved = await moveResolvedPlannedJobToStatus(options.storageRoot, options.resolvedJob, "shelved", options.moveFileSystem, {
+    shelvedCollisionTimestamp: timestamp
+  });
   if (moved.type !== "success")
     return moved;
   const solution = createSolutionUtils(options.fileSystem, options.storageRoot, {
     getDirectory: async () => moved.job.directory,
-    now: options.now
+    now: () => timestamp
   });
   const logged = await solution.log(moved.job.job_name, "update_status" /* UpdateStatus */, "shelved", options.assistantResponseText, "Job shelved.");
   const title = await updateCurrentSessionTitleToJobName(options.client, options.context, moved.job.job_name, moved.job.status);
   const sandboxDeps = options.sandboxDependencies ?? { ...defaultSandboxDependencies, fileSystem: options.fileSystem };
-  const sandboxArchive = await archiveJobSandboxesForShelvedJob(options.storageRoot, moved.job.job_name, moved.job.absolute_path, sandboxDeps);
+  const sandboxArchive = await archiveJobSandboxesForShelvedJob(options.storageRoot, options.resolvedJob.job_name, moved.job.absolute_path, sandboxDeps);
   return {
     type: "success",
     moved,
     solution: logged,
     title,
-    sandbox_archive: sandboxArchive
+    sandbox_archive: {
+      ...sandboxArchive,
+      job_name: moved.job.job_name
+    }
   };
 }
 
+// src/tools/autocode_job_shelve.ts
+async function readDirectory7(dirPath, options) {
+  return options?.withFileTypes ? readdir9(dirPath, { withFileTypes: true }) : readdir9(dirPath);
+}
+var defaultFileSystem8 = {
+  mkdir: mkdir9,
+  readFile: readFile9,
+  readdir: readDirectory7,
+  rename: rename6,
+  rm: rm6,
+  stat: stat6,
+  writeFile: writeFile9
+};
+function normalizeShelveToolArgs(clientOrFileSystem, fileSystemOrNow, maybeNow) {
+  if (typeof fileSystemOrNow === "function") {
+    return { fileSystem: clientOrFileSystem ?? defaultFileSystem8, now: fileSystemOrNow };
+  }
+  if (fileSystemOrNow) {
+    return { client: clientOrFileSystem, fileSystem: fileSystemOrNow, now: maybeNow ?? (() => new Date) };
+  }
+  const candidate = clientOrFileSystem;
+  if (candidate && "readFile" in candidate && "writeFile" in candidate) {
+    return { fileSystem: candidate, now: () => new Date };
+  }
+  return { client: candidate, fileSystem: defaultFileSystem8, now: () => new Date };
+}
+function createMissingIdentityRetryResponse() {
+  return createLifecycleJobRequiredRetryResponse("shelve job");
+}
+function createMissingJobRetryResponse2(jobName) {
+  return createLifecycleJobRequiredRetryResponse("shelve job", `job ${jobName}`);
+}
+function getIdentityRetryResponse(identity) {
+  if (identity.job_name) {
+    if (identity.resolution === "collision") {
+      return createRetryResponse("shelve job", `Planned job lifecycle collision: ${identity.job_name}`, "Resolve duplicate active lifecycle directories for this job before shelving.");
+    }
+    if (identity.resolution === "missing") {
+      return createMissingJobRetryResponse2(identity.job_name);
+    }
+  }
+  return createMissingIdentityRetryResponse();
+}
+function createAutocodeJobShelveTool(clientOrFileSystem, fileSystemOrNow, maybeNow) {
+  const { client, fileSystem, now } = normalizeShelveToolArgs(clientOrFileSystem, fileSystemOrNow, maybeNow);
+  return tool({
+    description: "Shelve current lifecycle job into .agents/jobs/shelved/{name}/.",
+    args: {},
+    async execute(_args, context) {
+      if (!client) {
+        return createMissingIdentityRetryResponse();
+      }
+      try {
+        const storageRoot = resolveAgentsStorageRoot(context);
+        const directoryFileSystem = createDirectoryFileSystem(fileSystem);
+        const identity = await resolvePlannedJobIdentity(directoryFileSystem, client, context, { includeShelved: true });
+        if (identity.mode !== "planned" || !identity.job_name) {
+          return getIdentityRetryResponse(identity);
+        }
+        const jobName = identity.job_name;
+        const resolvedJob = identity.resolved_job;
+        if (!resolvedJob) {
+          return createAbortResponse("shelve job", "Resolved planned-job identity is missing lifecycle details.");
+        }
+        if (!directoryFileSystem.rename) {
+          return createAbortResponse("shelve job", "Unable to move planned job lifecycle directory: rename is unavailable");
+        }
+        const reportContentResult = await readLatestAssistantResponseText(client, context);
+        if (reportContentResult.error) {
+          return createAbortResponse("inspect current session messages", reportContentResult.error);
+        }
+        if (reportContentResult.limitation) {
+          return createAbortResponse("inspect current session messages", reportContentResult.limitation);
+        }
+        if (!reportContentResult.text?.trim()) {
+          return createRetryResponse("shelve job", "No assistant response text was found in the current session.", "First present the user-facing lifecycle update in assistant text with concrete actions and a separate reason/evidence summary, then call autocode_job_shelve again.");
+        }
+        const shelved = await shelveResolvedPlannedJob({
+          storageRoot,
+          client,
+          context,
+          fileSystem,
+          moveFileSystem: { ...directoryFileSystem, rename: directoryFileSystem.rename },
+          now,
+          resolvedJob,
+          assistantResponseText: reportContentResult.text
+        });
+        if (shelved.type === "missing") {
+          return createMissingJobRetryResponse2(jobName);
+        }
+        if (shelved.type === "collision") {
+          return createRetryResponse("shelve job", `Planned job lifecycle collision: ${jobName}`, "Resolve duplicate active lifecycle directories for this job before shelving.");
+        }
+        if (shelved.type === "destination_collision") {
+          return createRetryResponse("shelve job", `Destination lifecycle directory already exists for ${jobName}`, "Resolve the existing lifecycle directory collision before shelving.");
+        }
+        if (!shelved.sandbox_archive.ok) {
+          return createRetryResponse("archive job sandboxes", shelved.sandbox_archive.reason, "Resolve the sandbox archive collision or unsafe path before retrying. Do not overwrite existing sandbox archives.");
+        }
+        return JSON.stringify({
+          job_name: shelved.moved.job.job_name,
+          current_status: "shelved",
+          job_path: shelved.moved.job.job_path,
+          solution_path: shelved.solution.relativeSolutionPath,
+          sandbox_archive: shelved.sandbox_archive,
+          title_warning: shelved.title.warning,
+          next_action: "Shelve complete; the job has no active lifecycle directory."
+        });
+      } catch (error45) {
+        return createAbortResponse("shelve job", error45);
+      }
+    }
+  });
+}
+
 // src/tools/autocode_job_status.ts
-async function readDirectory6(dirPath, options) {
-  return options?.withFileTypes ? readdir8(dirPath, { withFileTypes: true }) : readdir8(dirPath);
+import { mkdir as mkdir10, readFile as readFile10, readdir as readdir10, rename as rename7, rm as rm7, stat as stat7, writeFile as writeFile10 } from "fs/promises";
+async function readDirectory8(dirPath, options) {
+  return options?.withFileTypes ? readdir10(dirPath, { withFileTypes: true }) : readdir10(dirPath);
 }
-var defaultFileSystem7 = {
-  mkdir: mkdir8,
-  readFile: readFile8,
-  readdir: readDirectory6,
-  rename: rename5,
-  rm: rm5,
-  stat: stat5,
-  writeFile: writeFile8
+var defaultFileSystem9 = {
+  mkdir: mkdir10,
+  readFile: readFile10,
+  readdir: readDirectory8,
+  rename: rename7,
+  rm: rm7,
+  stat: stat7,
+  writeFile: writeFile10
 };
 function normalizeJobStatusToolArgs(clientOrFileSystem, fileSystemOrNow, maybeNow) {
   if (typeof fileSystemOrNow === "function") {
-    return { fileSystem: clientOrFileSystem ?? defaultFileSystem7, now: fileSystemOrNow };
+    return { fileSystem: clientOrFileSystem ?? defaultFileSystem9, now: fileSystemOrNow };
   }
   if (fileSystemOrNow) {
     return { client: clientOrFileSystem, fileSystem: fileSystemOrNow, now: maybeNow ?? (() => new Date) };
@@ -22337,18 +22809,18 @@ function normalizeJobStatusToolArgs(clientOrFileSystem, fileSystemOrNow, maybeNo
   if (candidate && "readFile" in candidate && "writeFile" in candidate) {
     return { fileSystem: candidate, now: () => new Date };
   }
-  return { client: candidate, fileSystem: defaultFileSystem7, now: () => new Date };
+  return { client: candidate, fileSystem: defaultFileSystem9, now: () => new Date };
 }
-function createMissingJobRetryResponse(jobName) {
+function createMissingJobRetryResponse3(jobName) {
   return createLifecycleJobRequiredRetryResponse("update job status", `job ${jobName}`);
 }
-function createCollisionRetryResponse(jobName, status) {
+function createCollisionRetryResponse2(jobName, status) {
   return createRetryResponse("update job status", `Planned job lifecycle collision: ${jobName}`, status === "shelved" ? "Resolve duplicate active lifecycle directories for this job before shelving." : "Resolve duplicate active lifecycle directories for this job before retrying.");
 }
 function createNextAction(status) {
   return status === "shelved" ? "Shelve complete; the job has no active lifecycle directory." : `Continue the job from status ${status}.`;
 }
-function createMissingIdentityRetryResponse() {
+function createMissingIdentityRetryResponse2() {
   return createLifecycleJobRequiredRetryResponse("update job status");
 }
 function getRequestedStatus(args) {
@@ -22366,16 +22838,16 @@ function getRequestedStatus(args) {
     error: createRetryResponse("update job status", `Invalid status: ${args.status}`, "Use one of: concepts, drafts, assist, executing, facilitate, review, shelved.")
   };
 }
-function getIdentityRetryResponse(identity, status) {
+function getIdentityRetryResponse2(identity, status) {
   if (identity.job_name) {
     if (identity.resolution === "collision") {
-      return createCollisionRetryResponse(identity.job_name, status);
+      return createCollisionRetryResponse2(identity.job_name, status);
     }
     if (identity.resolution === "missing") {
-      return createMissingJobRetryResponse(identity.job_name);
+      return createMissingJobRetryResponse3(identity.job_name);
     }
   }
-  return createMissingIdentityRetryResponse();
+  return createMissingIdentityRetryResponse2();
 }
 function createAutocodeJobStatusTool(clientOrFileSystem, fileSystemOrNow, maybeNow) {
   const { client, fileSystem, now } = normalizeJobStatusToolArgs(clientOrFileSystem, fileSystemOrNow, maybeNow);
@@ -22390,7 +22862,7 @@ function createAutocodeJobStatusTool(clientOrFileSystem, fileSystemOrNow, maybeN
         return requestedStatusResult.error;
       }
       if (!client) {
-        return createMissingIdentityRetryResponse();
+        return createMissingIdentityRetryResponse2();
       }
       try {
         const storageRoot = resolveAgentsStorageRoot(context);
@@ -22398,7 +22870,7 @@ function createAutocodeJobStatusTool(clientOrFileSystem, fileSystemOrNow, maybeN
         const status = requestedStatusResult.status;
         const identity = await resolvePlannedJobIdentity(directoryFileSystem, client, context, { includeShelved: status === "shelved" });
         if (identity.mode !== "planned" || !identity.job_name) {
-          return getIdentityRetryResponse(identity, status);
+          return getIdentityRetryResponse2(identity, status);
         }
         const jobName = identity.job_name;
         const resolvedJob = identity.resolved_job;
@@ -22435,10 +22907,10 @@ function createAutocodeJobStatusTool(clientOrFileSystem, fileSystemOrNow, maybeN
             assistantResponseText: reportContentResult.text
           });
           if (shelved.type === "missing") {
-            return createMissingJobRetryResponse(jobName);
+            return createMissingJobRetryResponse3(jobName);
           }
           if (shelved.type === "collision") {
-            return createCollisionRetryResponse(jobName, effectiveStatus);
+            return createCollisionRetryResponse2(jobName, effectiveStatus);
           }
           if (shelved.type === "destination_collision") {
             return createRetryResponse("update job status", `Destination lifecycle directory already exists for ${jobName}`, "Resolve the existing lifecycle directory collision before shelving.");
@@ -22458,10 +22930,10 @@ function createAutocodeJobStatusTool(clientOrFileSystem, fileSystemOrNow, maybeN
         }
         const moved = await movePlannedJobToStatus(storageRoot, jobName, effectiveStatus, moveFileSystem);
         if (moved.type === "missing") {
-          return createMissingJobRetryResponse(jobName);
+          return createMissingJobRetryResponse3(jobName);
         }
         if (moved.type === "collision") {
-          return createCollisionRetryResponse(jobName, effectiveStatus);
+          return createCollisionRetryResponse2(jobName, effectiveStatus);
         }
         if (moved.type === "destination_collision") {
           return createRetryResponse("update job status", `Destination lifecycle directory already exists for ${jobName}`, "Resolve the existing lifecycle directory collision before retrying.");
@@ -22489,7 +22961,7 @@ function createAutocodeJobStatusTool(clientOrFileSystem, fileSystemOrNow, maybeN
 // src/tools/autocode_logo_find.ts
 import { access } from "fs/promises";
 import path9 from "path";
-var defaultFileSystem8 = {
+var defaultFileSystem10 = {
   access
 };
 var logoBasePaths = [
@@ -22513,7 +22985,7 @@ function logoNotFoundResult(searched) {
     searched
   });
 }
-function createAutocodeLogoFindTool(fileSystem = defaultFileSystem8) {
+function createAutocodeLogoFindTool(fileSystem = defaultFileSystem10) {
   return tool({
     description: "Find project logo path.",
     args: {},
@@ -22542,10 +23014,10 @@ function createAutocodeLogoFindTool(fileSystem = defaultFileSystem8) {
 }
 
 // src/tools/autocode_plan_read.ts
-import { readFile as readFile10, readdir as readdir10 } from "fs/promises";
+import { readFile as readFile12, readdir as readdir12 } from "fs/promises";
 
 // src/tools/autocode_plan_save.ts
-import { mkdir as mkdir9, readFile as readFile9, readdir as readdir9, rm as rm6, stat as stat6, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile11, readdir as readdir11, rm as rm8, stat as stat8, writeFile as writeFile11 } from "fs/promises";
 import path10 from "path";
 var planSections = ["problems", "requirements", "constraints", "risks", "proposal"];
 var planSectionContentDescriptions = {
@@ -22595,16 +23067,16 @@ Propose ideal solution to solve \`problem\`:
 - Never repeat any info already provided in other plan sections/parameters
 `
 };
-async function readDirectory7(dirPath, options) {
-  return readdir9(dirPath, options);
+async function readDirectory9(dirPath, options) {
+  return readdir11(dirPath, options);
 }
-var defaultFileSystem9 = {
-  mkdir: mkdir9,
-  readFile: readFile9,
-  rm: rm6,
-  readdir: readDirectory7,
-  stat: stat6,
-  writeFile: writeFile9
+var defaultFileSystem11 = {
+  mkdir: mkdir11,
+  readFile: readFile11,
+  rm: rm8,
+  readdir: readDirectory9,
+  stat: stat8,
+  writeFile: writeFile11
 };
 function isPlanJobDirectory(directory) {
   return directory === completedJobLifecycleDirectory || activeJobLifecycleDirectories.includes(directory);
@@ -22796,7 +23268,7 @@ function normalizePlanToolArgs(clientOrFileSystem, maybeFileSystem) {
   if (candidate && "readFile" in candidate && "writeFile" in candidate) {
     return { fileSystem: candidate };
   }
-  return { client: candidate, fileSystem: defaultFileSystem9 };
+  return { client: candidate, fileSystem: defaultFileSystem11 };
 }
 function createAutocodePlanSaveTool(clientOrFileSystem, maybeFileSystem) {
   const { client, fileSystem } = normalizePlanToolArgs(clientOrFileSystem, maybeFileSystem);
@@ -22842,17 +23314,17 @@ function createAutocodePlanSaveTool(clientOrFileSystem, maybeFileSystem) {
 }
 
 // src/tools/autocode_plan_read.ts
-async function readDirectory8(dirPath, options) {
-  return readdir10(dirPath, options);
+async function readDirectory10(dirPath, options) {
+  return readdir12(dirPath, options);
 }
-var defaultFileSystem10 = {
-  readFile: readFile10,
-  readdir: readDirectory8
+var defaultFileSystem12 = {
+  readFile: readFile12,
+  readdir: readDirectory10
 };
 function createPlanResolverFileSystem(fileSystem) {
   return {
     readFile: fileSystem.readFile,
-    readdir: fileSystem.readdir ?? readDirectory8
+    readdir: fileSystem.readdir ?? readDirectory10
   };
 }
 function normalizePlanReadToolArgs(clientOrFileSystem, maybeFileSystem) {
@@ -22863,7 +23335,7 @@ function normalizePlanReadToolArgs(clientOrFileSystem, maybeFileSystem) {
   if (candidate && "readFile" in candidate) {
     return { fileSystem: candidate };
   }
-  return { client: candidate, fileSystem: defaultFileSystem10 };
+  return { client: candidate, fileSystem: defaultFileSystem12 };
 }
 function createAutocodePlanReadTool(clientOrFileSystem, maybeFileSystem) {
   const { client, fileSystem } = normalizePlanReadToolArgs(clientOrFileSystem, maybeFileSystem);
@@ -23431,7 +23903,7 @@ function createAutocodeSandboxDeleteTool(client, deps = defaultSandboxDependenci
 }
 
 // src/tools/autocode_sandbox_file_tools.ts
-import { lstat as lstat3, mkdir as mkdir10, readFile as readFileBuffer, readdir as readdir11, realpath as realpath2, rm as rm7, stat as stat7 } from "fs/promises";
+import { lstat as lstat3, mkdir as mkdir12, readFile as readFileBuffer, readdir as readdir13, realpath as realpath2, rm as rm9, stat as stat9 } from "fs/promises";
 import path14 from "path";
 
 // src/utils/sandbox_file_tools.ts
@@ -29614,7 +30086,7 @@ function normalizePattern(input) {
 }
 async function createEntry(root, absolutePath) {
   const direntStat = await lstat3(absolutePath);
-  const fileStat = direntStat.isSymbolicLink() ? direntStat : await stat7(absolutePath).catch(() => direntStat);
+  const fileStat = direntStat.isSymbolicLink() ? direntStat : await stat9(absolutePath).catch(() => direntStat);
   const type = direntStat.isSymbolicLink() ? "symlink" : fileStat.isDirectory() ? "directory" : "file";
   return {
     path: sandboxRelativePath(root, absolutePath),
@@ -29632,7 +30104,7 @@ async function isSafeDiscoveredPath(root, absolutePath) {
   return relative2 === "" || !relative2.startsWith("..") && !path14.isAbsolute(relative2);
 }
 async function walk(start, visitor) {
-  const entries = await readdir11(start, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir13(start, { withFileTypes: true }).catch(() => []);
   const sorted = entries.sort((left, right) => left.name.localeCompare(right.name));
   for (const entry of sorted) {
     const absolutePath = path14.join(start, entry.name);
@@ -29699,7 +30171,7 @@ function createAutocodeSandboxEditTool(client, deps = defaultSandboxDependencies
         } else {
           content = args2.newString;
         }
-        await mkdir10(path14.dirname(target.value.absolutePath), { recursive: true });
+        await mkdir12(path14.dirname(target.value.absolutePath), { recursive: true });
         await deps.fileSystem.writeFile(target.value.absolutePath, content);
         return JSON.stringify({ operation: "write", target: target.value.relativePath, path: target.value.relativePath, resource: `sandbox:${sandbox3.paths.sandboxName}/${target.value.relativePath}`, existed, replacements });
       } catch (error45) {
@@ -29775,7 +30247,7 @@ function createAutocodeSandboxGrepTool(client, deps = defaultSandboxDependencies
         await walk(base.value.absolutePath, async (absolutePath) => {
           if (!await isSafeDiscoveredPath(sandbox3.metadata.root_path, absolutePath))
             return true;
-          const fileStat = await stat7(absolutePath).catch(() => {
+          const fileStat = await stat9(absolutePath).catch(() => {
             return;
           });
           if (!fileStat?.isFile())
@@ -29844,9 +30316,9 @@ function createAutocodeSandboxReadTool(client, deps = defaultSandboxDependencies
         const target = await resolveSafeRelativePath(sandbox3.metadata.root_path, args2.path, "path", true, true);
         if (!target.ok)
           return createRetryResponse("read sandbox path", target.reason, "Use a sandbox-root-relative path.");
-        const fileStat = await stat7(target.value.absolutePath);
+        const fileStat = await stat9(target.value.absolutePath);
         if (fileStat.isDirectory()) {
-          const entries = await readdir11(target.value.absolutePath);
+          const entries = await readdir13(target.value.absolutePath);
           const listed = await Promise.all(entries.sort((left, right) => left.localeCompare(right)).slice(0, normalizeLimit(args2.limit, defaultLimit, maximumLimit)).map((entry) => createEntry(sandbox3.metadata.root_path, path14.join(target.value.absolutePath, entry))));
           return JSON.stringify({ path: target.value.relativePath, type: "directory", entries: listed });
         }
@@ -29900,17 +30372,17 @@ function createAutocodeSandboxCopyTool(client, deps = defaultSandboxDependencies
         const target = await validateSafeWriteTarget(targetRoot, args2.local_target ?? args2.sandbox_target, "target", args2.sandbox_target !== undefined);
         if (!target.ok)
           return createRetryResponse("copy sandbox path", target.reason, "Use a safe target path inside project root or sandbox storage.");
-        const sourceStat = await stat7(source.value.absolutePath);
-        const targetStat = await stat7(target.value.absolutePath).catch(() => {
+        const sourceStat = await stat9(source.value.absolutePath);
+        const targetStat = await stat9(target.value.absolutePath).catch(() => {
           return;
         });
         if (sourceStat.isDirectory() && targetStat?.isFile())
           return createRetryResponse("copy sandbox path", "Cannot copy directory onto existing file.", "Choose a directory target or remove the file first.");
         if (sourceStat.isFile() && targetStat?.isDirectory())
           return createRetryResponse("copy sandbox path", "Cannot copy file onto existing directory.", "Choose a file target or remove the directory first.");
-        await mkdir10(path14.dirname(target.value.absolutePath), { recursive: true });
+        await mkdir12(path14.dirname(target.value.absolutePath), { recursive: true });
         if (sourceStat.isFile() && targetStat?.isFile())
-          await rm7(target.value.absolutePath, { force: true });
+          await rm9(target.value.absolutePath, { force: true });
         await copyPath(source.value.absolutePath, target.value.absolutePath);
         return JSON.stringify({ operation: "copy", source: source.value.relativePath, target: target.value.relativePath, resource: args2.sandbox_target !== undefined ? `sandbox:${sandbox3.paths.sandboxName}/${target.value.relativePath}` : `local:${target.value.relativePath}` });
       } catch (error45) {
@@ -29956,122 +30428,6 @@ function createAutocodeSessionCreateTool(client) {
   });
 }
 
-// src/tools/autocode_shelve.ts
-import { mkdir as mkdir11, readFile as readFile11, readdir as readdir12, rename as rename6, rm as rm8, stat as stat8, writeFile as writeFile10 } from "fs/promises";
-async function readDirectory9(dirPath, options) {
-  return options?.withFileTypes ? readdir12(dirPath, { withFileTypes: true }) : readdir12(dirPath);
-}
-var defaultFileSystem11 = {
-  mkdir: mkdir11,
-  readFile: readFile11,
-  readdir: readDirectory9,
-  rename: rename6,
-  rm: rm8,
-  stat: stat8,
-  writeFile: writeFile10
-};
-function normalizeShelveToolArgs(clientOrFileSystem, fileSystemOrNow, maybeNow) {
-  if (typeof fileSystemOrNow === "function") {
-    return { fileSystem: clientOrFileSystem ?? defaultFileSystem11, now: fileSystemOrNow };
-  }
-  if (fileSystemOrNow) {
-    return { client: clientOrFileSystem, fileSystem: fileSystemOrNow, now: maybeNow ?? (() => new Date) };
-  }
-  const candidate = clientOrFileSystem;
-  if (candidate && "readFile" in candidate && "writeFile" in candidate) {
-    return { fileSystem: candidate, now: () => new Date };
-  }
-  return { client: candidate, fileSystem: defaultFileSystem11, now: () => new Date };
-}
-function createMissingIdentityRetryResponse2() {
-  return createLifecycleJobRequiredRetryResponse("shelve job");
-}
-function createMissingJobRetryResponse2(jobName) {
-  return createLifecycleJobRequiredRetryResponse("shelve job", `job ${jobName}`);
-}
-function getIdentityRetryResponse2(identity3) {
-  if (identity3.job_name) {
-    if (identity3.resolution === "collision") {
-      return createRetryResponse("shelve job", `Planned job lifecycle collision: ${identity3.job_name}`, "Resolve duplicate active lifecycle directories for this job before shelving.");
-    }
-    if (identity3.resolution === "missing") {
-      return createMissingJobRetryResponse2(identity3.job_name);
-    }
-  }
-  return createMissingIdentityRetryResponse2();
-}
-function createAutocodeShelveTool(clientOrFileSystem, fileSystemOrNow, maybeNow) {
-  const { client, fileSystem, now } = normalizeShelveToolArgs(clientOrFileSystem, fileSystemOrNow, maybeNow);
-  return tool({
-    description: "Shelve current lifecycle job into .agents/jobs/shelved/{name}/.",
-    args: {},
-    async execute(_args, context3) {
-      if (!client) {
-        return createMissingIdentityRetryResponse2();
-      }
-      try {
-        const storageRoot = resolveAgentsStorageRoot(context3);
-        const directoryFileSystem = createDirectoryFileSystem(fileSystem);
-        const identity3 = await resolvePlannedJobIdentity(directoryFileSystem, client, context3, { includeShelved: true });
-        if (identity3.mode !== "planned" || !identity3.job_name) {
-          return getIdentityRetryResponse2(identity3);
-        }
-        const jobName = identity3.job_name;
-        const resolvedJob = identity3.resolved_job;
-        if (!resolvedJob) {
-          return createAbortResponse("shelve job", "Resolved planned-job identity is missing lifecycle details.");
-        }
-        if (!directoryFileSystem.rename) {
-          return createAbortResponse("shelve job", "Unable to move planned job lifecycle directory: rename is unavailable");
-        }
-        const reportContentResult = await readLatestAssistantResponseText(client, context3);
-        if (reportContentResult.error) {
-          return createAbortResponse("inspect current session messages", reportContentResult.error);
-        }
-        if (reportContentResult.limitation) {
-          return createAbortResponse("inspect current session messages", reportContentResult.limitation);
-        }
-        if (!reportContentResult.text?.trim()) {
-          return createRetryResponse("shelve job", "No assistant response text was found in the current session.", "First present the user-facing lifecycle update in assistant text with concrete actions and a separate reason/evidence summary, then call autocode_shelve again.");
-        }
-        const shelved = await shelveResolvedPlannedJob({
-          storageRoot,
-          client,
-          context: context3,
-          fileSystem,
-          moveFileSystem: { ...directoryFileSystem, rename: directoryFileSystem.rename },
-          now,
-          resolvedJob,
-          assistantResponseText: reportContentResult.text
-        });
-        if (shelved.type === "missing") {
-          return createMissingJobRetryResponse2(jobName);
-        }
-        if (shelved.type === "collision") {
-          return createRetryResponse("shelve job", `Planned job lifecycle collision: ${jobName}`, "Resolve duplicate active lifecycle directories for this job before shelving.");
-        }
-        if (shelved.type === "destination_collision") {
-          return createRetryResponse("shelve job", `Destination lifecycle directory already exists for ${jobName}`, "Resolve the existing lifecycle directory collision before shelving.");
-        }
-        if (!shelved.sandbox_archive.ok) {
-          return createRetryResponse("archive job sandboxes", shelved.sandbox_archive.reason, "Resolve the sandbox archive collision or unsafe path before retrying. Do not overwrite existing sandbox archives.");
-        }
-        return JSON.stringify({
-          job_name: shelved.moved.job.job_name,
-          current_status: "shelved",
-          job_path: shelved.moved.job.job_path,
-          solution_path: shelved.solution.relativeSolutionPath,
-          sandbox_archive: shelved.sandbox_archive,
-          title_warning: shelved.title.warning,
-          next_action: "Shelve complete; the job has no active lifecycle directory."
-        });
-      } catch (error45) {
-        return createAbortResponse("shelve job", error45);
-      }
-    }
-  });
-}
-
 // src/tools/task_external.ts
 import { spawn as nodeSpawn2 } from "child_process";
 import { realpath as nodeRealpath, stat as nodeStat } from "fs/promises";
@@ -30620,6 +30976,8 @@ function createTaskResumeTool(client) {
 // src/tools/index.ts
 function createTools(client, sandboxConfig = {}) {
   return {
+    autocode_agent_execute: createAutocodeAgentExecuteTool(client),
+    autocode_agent_previous: createAutocodeAgentPreviousTool(client),
     autocode_agent_swap: createAutocodeAgentSwapTool(client),
     autocode_concept_create: createAutocodeConceptCreateTool(client),
     autocode_concept_list: createAutocodeConceptListTool(),
@@ -30635,8 +30993,8 @@ function createTools(client, sandboxConfig = {}) {
     autocode_dependencies: createAutocodeDependenciesTool(),
     autocode_job_list: createAutocodeJobListTool(),
     autocode_job_execute: createAutocodeJobExecuteTool(client),
+    autocode_job_shelve: createAutocodeJobShelveTool(client),
     autocode_job_status: createAutocodeJobStatusTool(client),
-    autocode_shelve: createAutocodeShelveTool(client),
     autocode_logo_find: createAutocodeLogoFindTool(),
     autocode_plan_read: createAutocodePlanReadTool(client),
     autocode_plan_save: createAutocodePlanSaveTool(client),