refactor: sync delegate_task schema with OpenCode Task tool (resume→session_id, add command param)

Author: justsisyphus

src/agents/atlas.ts

@@ -323,32 +323,32 @@ delegate_task(
 **If verification fails**: Resume the SAME session with the ACTUAL error output:
 \`\`\`typescript
 delegate_task(
-  resume="ses_xyz789",  // ALWAYS use the session from the failed task
+  session_id="ses_xyz789",  // ALWAYS use the session from the failed task
   load_skills=[...],
   prompt="Verification failed: {actual error}. Fix."
 )
 \`\`\`
 
 ### 3.5 Handle Failures (USE RESUME)
 
-**CRITICAL: When re-delegating, ALWAYS use \`resume\` parameter.**
+**CRITICAL: When re-delegating, ALWAYS use \`session_id\` parameter.**
 
 Every \`delegate_task()\` output includes a session_id. STORE IT.
 
 If task fails:
 1. Identify what went wrong
 2. **Resume the SAME session** - subagent has full context already:
-   \`\`\`typescript
-   delegate_task(
-     resume="ses_xyz789",  // Session from failed task
-     load_skills=[...],
-     prompt="FAILED: {error}. Fix by: {specific instruction}"
-   )
-   \`\`\`
+    \`\`\`typescript
+    delegate_task(
+      session_id="ses_xyz789",  // Session from failed task
+      load_skills=[...],
+      prompt="FAILED: {error}. Fix by: {specific instruction}"
+    )
+    \`\`\`
 3. Maximum 3 retry attempts with the SAME session
 4. If blocked after 3 attempts: Document and continue to independent tasks
 
-**Why resume is MANDATORY for failures:**
+**Why session_id is MANDATORY for failures:**
 - Subagent already read all files, knows the context
 - No repeated exploration = 70%+ token savings
 - Subagent knows what approaches already failed
@@ -493,7 +493,7 @@ You are the QA gate. Subagents lie. Verify EVERYTHING.
 - Parallelize independent tasks
 - Verify with your own tools
 - **Store session_id from every delegation output**
-- **Use \`resume="{session_id}"\` for retries, fixes, and follow-ups**
+- **Use \`session_id="{session_id}"\` for retries, fixes, and follow-ups**
 </critical_overrides>
 `
 

src/agents/sisyphus.ts

@@ -209,15 +209,15 @@ AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS AS FOLLOWING:
 
 Every \`delegate_task()\` output includes a session_id. **USE IT.**
 
-**ALWAYS resume when:**
+**ALWAYS continue when:**
 | Scenario | Action |
 |----------|--------|
-| Task failed/incomplete | \`resume="{session_id}", prompt="Fix: {specific error}"\` |
-| Follow-up question on result | \`resume="{session_id}", prompt="Also: {question}"\` |
-| Multi-turn with same agent | \`resume="{session_id}"\` - NEVER start fresh |
-| Verification failed | \`resume="{session_id}", prompt="Failed verification: {error}. Fix."\` |
+| Task failed/incomplete | \`session_id="{session_id}", prompt="Fix: {specific error}"\` |
+| Follow-up question on result | \`session_id="{session_id}", prompt="Also: {question}"\` |
+| Multi-turn with same agent | \`session_id="{session_id}"\` - NEVER start fresh |
+| Verification failed | \`session_id="{session_id}", prompt="Failed verification: {error}. Fix."\` |
 
-**Why resume is CRITICAL:**
+**Why session_id is CRITICAL:**
 - Subagent has FULL conversation context preserved
 - No repeated file reads, exploration, or setup
 - Saves 70%+ tokens on follow-ups
@@ -228,10 +228,10 @@ Every \`delegate_task()\` output includes a session_id. **USE IT.**
 delegate_task(category="quick", prompt="Fix the type error in auth.ts...")
 
 // CORRECT: Resume preserves everything
-delegate_task(resume="ses_abc123", prompt="Fix: Type error on line 42")
+delegate_task(session_id="ses_abc123", prompt="Fix: Type error on line 42")
 \`\`\`
 
-**After EVERY delegation, STORE the session_id for potential resume.**
+**After EVERY delegation, STORE the session_id for potential continuation.**
 
 ### Code Changes:
 - Match existing patterns (if codebase is disciplined)

src/hooks/atlas/index.test.ts

@@ -141,7 +141,7 @@ describe("atlas hook", () => {
       // #then - standalone verification reminder appended
       expect(output.output).toContain("Task completed successfully")
       expect(output.output).toContain("MANDATORY:")
-      expect(output.output).toContain("delegate_task(resume=")
+      expect(output.output).toContain("delegate_task(session_id=")
 
       cleanupMessageStorage(sessionID)
     })
@@ -180,7 +180,7 @@ describe("atlas hook", () => {
       expect(output.output).toContain("SUBAGENT WORK COMPLETED")
       expect(output.output).toContain("test-plan")
       expect(output.output).toContain("LIE")
-      expect(output.output).toContain("delegate_task(resume=")
+      expect(output.output).toContain("delegate_task(session_id=")
 
       cleanupMessageStorage(sessionID)
     })
@@ -332,7 +332,7 @@ describe("atlas hook", () => {
       cleanupMessageStorage(sessionID)
     })
 
-     test("should include resume and checkbox instructions in reminder", async () => {
+     test("should include session_id and checkbox instructions in reminder", async () => {
        // #given - boulder state, Atlas caller
        const sessionID = "session-resume-test"
        setupMessageStorage(sessionID, "atlas")
@@ -361,8 +361,8 @@ describe("atlas hook", () => {
         output
       )
 
-      // #then - should include resume instructions and verification
-      expect(output.output).toContain("delegate_task(resume=")
+      // #then - should include session_id instructions and verification
+      expect(output.output).toContain("delegate_task(session_id=")
       expect(output.output).toContain("[x]")
       expect(output.output).toContain("MANDATORY:")
 

src/hooks/atlas/index.ts

@@ -179,13 +179,13 @@ If you were NOT given **exactly ONE atomic task**, you MUST:
 `
 
 function buildVerificationReminder(sessionId: string): string {
-  return `${VERIFICATION_REMINDER}
+   return `${VERIFICATION_REMINDER}
 
 ---
 
 **If ANY verification fails, use this immediately:**
 \`\`\`
-delegate_task(resume="${sessionId}", prompt="fix: [describe the specific failure]")
+delegate_task(session_id="${sessionId}", prompt="fix: [describe the specific failure]")
 \`\`\``
 }
 
@@ -711,8 +711,8 @@ export function createAtlasHook(
         return
       }
 
-      const outputStr = output.output && typeof output.output === "string" ? output.output : ""
-      const isBackgroundLaunch = outputStr.includes("Background task launched") || outputStr.includes("Background task resumed")
+       const outputStr = output.output && typeof output.output === "string" ? output.output : ""
+       const isBackgroundLaunch = outputStr.includes("Background task launched") || outputStr.includes("Background task continued")
 
       if (isBackgroundLaunch) {
         return

src/hooks/task-resume-info/index.ts

@@ -16,21 +16,21 @@ function extractSessionId(output: string): string | null {
 }
 
 export function createTaskResumeInfoHook() {
-  const toolExecuteAfter = async (
-    input: { tool: string; sessionID: string; callID: string },
-    output: { title: string; output: string; metadata: unknown }
-  ) => {
-    if (!TARGET_TOOLS.includes(input.tool)) return
-    if (output.output.startsWith("Error:") || output.output.startsWith("Failed")) return
-    if (output.output.includes("\nto resume:")) return
+   const toolExecuteAfter = async (
+     input: { tool: string; sessionID: string; callID: string },
+     output: { title: string; output: string; metadata: unknown }
+   ) => {
+     if (!TARGET_TOOLS.includes(input.tool)) return
+     if (output.output.startsWith("Error:") || output.output.startsWith("Failed")) return
+     if (output.output.includes("\nto continue:")) return
 
-    const sessionId = extractSessionId(output.output)
-    if (!sessionId) return
+     const sessionId = extractSessionId(output.output)
+     if (!sessionId) return
 
-    output.output = output.output.trimEnd() + `\n\nto resume: delegate_task(resume="${sessionId}", prompt="...")`
-  }
+     output.output = output.output.trimEnd() + `\n\nto continue: delegate_task(session_id="${sessionId}", prompt="...")`
+   }
 
-  return {
-    "tool.execute.after": toolExecuteAfter,
-  }
+   return {
+     "tool.execute.after": toolExecuteAfter,
+   }
 }

src/tools/background-task/tools.ts

@@ -442,18 +442,18 @@ export function createBackgroundCancel(manager: BackgroundManager, client: Openc
             .map(t => `| \`${t.id}\` | ${t.description} | ${t.status} | ${t.sessionID ? `\`${t.sessionID}\`` : "(not started)"} |`)
             .join("\n")
 
-          const resumableTasks = cancelledInfo.filter(t => t.sessionID)
-          const resumeSection = resumableTasks.length > 0
-            ? `\n## Resume Instructions
+           const resumableTasks = cancelledInfo.filter(t => t.sessionID)
+           const resumeSection = resumableTasks.length > 0
+             ? `\n## Continue Instructions
 
-To resume a cancelled task, use:
+To continue a cancelled task, use:
 \`\`\`
-delegate_task(resume="<session_id>", prompt="Continue: <your follow-up>")
+delegate_task(session_id="<session_id>", prompt="Continue: <your follow-up>")
 \`\`\`
 
-Resumable sessions:
+Continuable sessions:
 ${resumableTasks.map(t => `- \`${t.sessionID}\` (${t.description})`).join("\n")}`
-            : ""
+             : ""
 
           return `Cancelled ${cancellableTasks.length} background task(s):
 

src/tools/call-omo-agent/constants.ts

@@ -4,4 +4,4 @@ export const CALL_OMO_AGENT_DESCRIPTION = `Spawn explore/librarian agent. run_in
 
 Available: {agents}
 
-Pass \`resume=session_id\` to continue previous agent with full context. Prompts MUST be in English. Use \`background_output\` for async results.`
+Pass \`session_id=<id>\` to continue previous agent with full context. Prompts MUST be in English. Use \`background_output\` for async results.`

src/tools/delegate-task/tools.test.ts

@@ -594,16 +594,16 @@ describe("sisyphus-task", () => {
     }, { timeout: 20000 })
   })
 
-  describe("resume with background parameter", () => {
-  test("resume with background=false should wait for result and return content", async () => {
+  describe("session_id with background parameter", () => {
+  test("session_id with background=false should wait for result and return content", async () => {
     // Note: This test needs extended timeout because the implementation has MIN_STABILITY_TIME_MS = 5000
     // #given
     const { createDelegateTask } = require("./tools")
 
     const mockTask = {
       id: "task-123",
-      sessionID: "ses_resume_test",
-      description: "Resumed task",
+      sessionID: "ses_continue_test",
+      description: "Continued task",
       agent: "explore",
       status: "running",
     }
@@ -620,7 +620,7 @@ describe("sisyphus-task", () => {
           data: [
             {
               info: { role: "assistant", time: { created: Date.now() } },
-              parts: [{ type: "text", text: "This is the resumed task result" }],
+              parts: [{ type: "text", text: "This is the continued task result" }],
             },
           ],
         }),
@@ -646,28 +646,28 @@ describe("sisyphus-task", () => {
     // #when
     const result = await tool.execute(
       {
-        description: "Resume test",
+        description: "Continue test",
         prompt: "Continue the task",
-        resume: "ses_resume_test",
+        session_id: "ses_continue_test",
         run_in_background: false,
         load_skills: ["git-master"],
       },
       toolContext
     )
 
-    // #then - should contain actual result, not just "Background task resumed"
-    expect(result).toContain("This is the resumed task result")
-    expect(result).not.toContain("Background task resumed")
+    // #then - should contain actual result, not just "Background task continued"
+    expect(result).toContain("This is the continued task result")
+    expect(result).not.toContain("Background task continued")
   }, { timeout: 10000 })
 
-  test("resume with background=true should return immediately without waiting", async () => {
+  test("session_id with background=true should return immediately without waiting", async () => {
     // #given
     const { createDelegateTask } = require("./tools")
 
     const mockTask = {
       id: "task-456",
-      sessionID: "ses_bg_resume",
-      description: "Background resumed task",
+      sessionID: "ses_bg_continue",
+      description: "Background continued task",
       agent: "explore",
       status: "running",
     }
@@ -701,17 +701,17 @@ describe("sisyphus-task", () => {
     // #when
     const result = await tool.execute(
       {
-        description: "Resume bg test",
+        description: "Continue bg test",
         prompt: "Continue in background",
-        resume: "ses_bg_resume",
+        session_id: "ses_bg_continue",
         run_in_background: true,
         load_skills: ["git-master"],
       },
       toolContext
     )
 
     // #then - should return background message
-    expect(result).toContain("Background task resumed")
+    expect(result).toContain("Background task continued")
     expect(result).toContain("task-456")
   })
 })