@slopus/rig 0.0.4 → 0.0.6

package/dist/tasks/types.d.ts

@@ -0,0 +1,39 @@
+export type TaskStatus = "pending" | "in_progress" | "completed";
+export interface SessionTask {
+    activeForm?: string;
+    blockedBy: readonly string[];
+    blocks: readonly string[];
+    description: string;
+    id: string;
+    metadata?: Readonly<Record<string, unknown>>;
+    owner?: string;
+    status: TaskStatus;
+    subject: string;
+}
+export interface CreateTaskRequest {
+    activeForm?: string;
+    description: string;
+    metadata?: Readonly<Record<string, unknown>>;
+    subject: string;
+}
+export interface UpdateTaskRequest {
+    activeForm?: string;
+    addBlockedBy?: readonly string[];
+    addBlocks?: readonly string[];
+    description?: string;
+    metadata?: Readonly<Record<string, unknown>>;
+    owner?: string;
+    status?: TaskStatus | "deleted";
+    subject?: string;
+}
+export interface UpdateTaskResult {
+    error?: string;
+    statusChange?: {
+        from: TaskStatus;
+        to: TaskStatus | "deleted";
+    };
+    success: boolean;
+    taskId: string;
+    updatedFields: readonly string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/tasks/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../sources/tasks/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,aAAa,GAAG,WAAW,CAAC;AAEjE,MAAM,WAAW,WAAW;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7C,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,EAAE,EAAE,UAAU,GAAG,SAAS,CAAA;KAAE,CAAC;IAChE,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC"}

package/dist/tasks/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/Agent.d.ts

@@ -1,9 +1,19 @@
 export declare const agentTool: import("../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
     description: import("@sinclair/typebox").TString;
     prompt: import("@sinclair/typebox").TString;
-}>, import("@sinclair/typebox").TObject<{
+    run_in_background: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
     output: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TString;
     sessionId: import("@sinclair/typebox").TString;
-    status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"aborted">, import("@sinclair/typebox").TLiteral<"completed">, import("@sinclair/typebox").TLiteral<"error">]>;
-}>>;
+    status: import("@sinclair/typebox").TLiteral<"completed">;
+    taskName: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    agentId: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TString;
+    prompt: import("@sinclair/typebox").TString;
+    status: import("@sinclair/typebox").TLiteral<"async_launched">;
+    taskName: import("@sinclair/typebox").TString;
+}>]>>;
 //# sourceMappingURL=Agent.d.ts.map

package/dist/tools/Agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Agent.d.ts","sourceRoot":"","sources":["../../sources/tools/Agent.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,SAAS;;;;;;;GAgDpB,CAAC"}
+{"version":3,"file":"Agent.d.ts","sourceRoot":"","sources":["../../sources/tools/Agent.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;KAoEpB,CAAC"}

package/dist/tools/Agent.js

@@ -1,14 +1,24 @@
 import { Type } from "@sinclair/typebox";
 import { defineTool } from "../agent/types.js";
-const agentResultSchema = Type.Object({
+const completedAgentResultSchema = Type.Object({
     output: Type.String(),
+    path: Type.String(),
     sessionId: Type.String(),
-    status: Type.Union([Type.Literal("aborted"), Type.Literal("completed"), Type.Literal("error")]),
+    status: Type.Literal("completed"),
+    taskName: Type.String(),
+});
+const backgroundAgentResultSchema = Type.Object({
+    agentId: Type.String(),
+    description: Type.String(),
+    path: Type.String(),
+    prompt: Type.String(),
+    status: Type.Literal("async_launched"),
+    taskName: Type.String(),
 });
 export const agentTool = defineTool({
     name: "Agent",
     label: "Agent",
-    description: "Start a synchronous subagent for a focused, self-contained task. The subagent has its own conversation history and returns its final response. It stops when this tool call is aborted.",
+    description: "Start a subagent for a focused, self-contained task. Run it in the foreground when its result is needed immediately, or in the background to keep working while it runs.",
     arguments: Type.Object({
         description: Type.String({
             description: "A short, human-readable description of the delegated task.",
@@ -16,34 +26,52 @@ export const agentTool = defineTool({
         prompt: Type.String({
             description: "Complete instructions for the subagent.",
         }),
+        run_in_background: Type.Optional(Type.Boolean({
+            description: "Set to true to run the subagent in the background. A completion notification will arrive later.",
+        })),
     }),
-    returnType: agentResultSchema,
-    execute: async ({ description, prompt }, context, execution) => {
+    returnType: Type.Union([completedAgentResultSchema, backgroundAgentResultSchema]),
+    execute: async ({ description, prompt, run_in_background }, context, execution) => {
         if (context.subagents === undefined || !context.subagents.canSpawn) {
             throw new Error("This agent has reached the maximum subagent depth.");
         }
         const result = await context.subagents.spawn({
             description,
+            ...(run_in_background === true ? { background: true } : {}),
             prompt,
             ...(execution.toolCallId !== undefined
                 ? { parentToolCallId: execution.toolCallId }
                 : {}),
         }, execution.signal);
+        if (result.status === "running") {
+            return {
+                agentId: result.sessionId,
+                description,
+                path: result.path,
+                prompt,
+                status: "async_launched",
+                taskName: result.taskName,
+            };
+        }
         if (result.status !== "completed") {
             throw new Error(result.output);
         }
-        return result;
+        return {
+            output: result.output,
+            path: result.path,
+            sessionId: result.sessionId,
+            status: "completed",
+            taskName: result.taskName,
+        };
     },
     toLLM: (result) => [
         {
             type: "text",
-            text: result.status === "completed"
-                ? result.output
-                : `The subagent ${result.status}. ${result.output}`,
+            text: result.status === "async_launched" ? JSON.stringify(result) : result.output,
         },
     ],
-    toUI: (result, args) => result.status === "completed"
-        ? `Completed: ${args.description}`
-        : `${result.status === "aborted" ? "Stopped" : "Failed"}: ${args.description}`,
+    toUI: (result, args) => result.status === "async_launched"
+        ? `Running in background: ${args.description}`
+        : `Completed: ${args.description}`,
     locks: [],
 });

package/dist/tools/claude/AskUserQuestion.d.ts

@@ -0,0 +1,23 @@
+export declare const claudeAskUserQuestionTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    questions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        question: import("@sinclair/typebox").TString;
+        header: import("@sinclair/typebox").TString;
+        options: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            label: import("@sinclair/typebox").TString;
+            description: import("@sinclair/typebox").TString;
+        }>>;
+        multiSelect: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>>;
+}>, import("@sinclair/typebox").TObject<{
+    questions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        question: import("@sinclair/typebox").TString;
+        header: import("@sinclair/typebox").TString;
+        options: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            label: import("@sinclair/typebox").TString;
+            description: import("@sinclair/typebox").TString;
+        }>>;
+        multiSelect: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>>;
+    answers: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>;
+}>>;
+//# sourceMappingURL=AskUserQuestion.d.ts.map

package/dist/tools/claude/AskUserQuestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AskUserQuestion.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/AskUserQuestion.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;GA8CpC,CAAC"}

package/dist/tools/claude/AskUserQuestion.js

@@ -0,0 +1,52 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+const optionSchema = Type.Object({
+    label: Type.String({ description: "Concise display text for this choice." }),
+    description: Type.String({ description: "Context about the choice and its tradeoffs." }),
+}, { additionalProperties: false });
+const questionSchema = Type.Object({
+    question: Type.String({ description: "The complete question to ask the user." }),
+    header: Type.String({
+        maxLength: 12,
+        description: "A very short label for the question, at most 12 characters.",
+    }),
+    options: Type.Array(optionSchema, { minItems: 2, maxItems: 4 }),
+    multiSelect: Type.Optional(Type.Boolean({ description: "Allow the user to select multiple choices." })),
+}, { additionalProperties: false });
+export const claudeAskUserQuestionTool = defineTool({
+    name: "AskUserQuestion",
+    label: "AskUserQuestion",
+    description: "Asks the user multiple-choice questions to clarify ambiguity, understand preferences, or make decisions.",
+    arguments: Type.Object({ questions: Type.Array(questionSchema, { minItems: 1, maxItems: 4 }) }, { additionalProperties: false }),
+    returnType: Type.Object({
+        questions: Type.Array(questionSchema),
+        answers: Type.Record(Type.String(), Type.String()),
+    }),
+    async execute({ questions }, context, execution) {
+        if (new Set(questions.map((question) => question.question)).size !== questions.length) {
+            throw new Error("Interactive question text must be unique.");
+        }
+        if (context.userInput === undefined) {
+            throw new Error("Interactive user input is unavailable in this session.");
+        }
+        if (execution.toolCallId === undefined) {
+            throw new Error("Interactive user input requires a tool call identifier.");
+        }
+        const normalizedQuestions = questions.map((question, index) => ({
+            ...question,
+            id: `question_${index + 1}`,
+            multiSelect: question.multiSelect ?? false,
+        }));
+        const response = await context.userInput.request({ requestId: execution.toolCallId, questions: normalizedQuestions }, execution.signal === undefined ? undefined : { signal: execution.signal });
+        return {
+            questions,
+            answers: Object.fromEntries(normalizedQuestions.map((question) => [
+                question.question,
+                (response.answers[question.id] ?? []).join(", "),
+            ])),
+        };
+    },
+    toLLM: (result) => [{ type: "text", text: JSON.stringify(result) }],
+    toUI: (_result, args) => `Answered ${args.questions.length} question${args.questions.length === 1 ? "" : "s"}`,
+    locks: ["user_input"],
+});

package/dist/tools/claude/Bash.d.ts

@@ -3,7 +3,9 @@ export declare const claudeBashTool: import("../../agent/types.js").DefinedTool<
     timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     run_in_background: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    dangerouslyDisableSandbox: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
 }>, import("@sinclair/typebox").TObject<{
+    backgroundTaskId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     stdout: import("@sinclair/typebox").TString;
     stderr: import("@sinclair/typebox").TString;
     exitCode: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TNull]>;

package/dist/tools/claude/Bash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Bash.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/Bash.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,cAAc;;;;;;;;;;GA8BzB,CAAC"}
+{"version":3,"file":"Bash.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/Bash.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,cAAc;;;;;;;;;;;;GAkDzB,CAAC"}

package/dist/tools/claude/Bash.js

@@ -12,14 +12,32 @@ export const claudeBashTool = defineTool({
             description: 'Clear, concise description of what this command does in active voice. Never use words like "complex" or "risk" in the description - just describe what it does.',
         })),
         run_in_background: Type.Optional(Type.Boolean({
-            description: "Set to true to run this command in the background. Use Read to read the output later.",
+            description: "Set to true to run this command in the background. Use TaskOutput to read the output later.",
+        })),
+        dangerouslyDisableSandbox: Type.Optional(Type.Boolean({
+            description: "Request reviewed execution outside the workspace sandbox in Auto mode. Use only when the sandbox blocks a necessary command.",
         })),
     }),
     returnType: shellToolOutputSchema,
-    execute: async ({ command, timeout }, context, execution) => {
+    execute: async ({ command, run_in_background, timeout }, context, execution) => {
+        if (run_in_background === true) {
+            const sessionId = await context.bash.startSession({
+                command,
+                timeoutMs: timeout ?? 120_000,
+            });
+            return {
+                backgroundTaskId: String(sessionId),
+                exitCode: null,
+                stderr: "",
+                stdout: "",
+                timedOut: false,
+            };
+        }
         const options = {};
         if (timeout !== undefined)
             options.timeoutMs = timeout;
+        if (execution.onProgress !== undefined)
+            options.onProgress = execution.onProgress;
         if (execution.signal !== undefined)
             options.signal = execution.signal;
         return runShellCommand(command, options, context);

package/dist/tools/claude/SendMessage.d.ts

@@ -0,0 +1,10 @@
+export declare const claudeSendMessageTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    to: import("@sinclair/typebox").TString;
+    summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    message: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    message: import("@sinclair/typebox").TString;
+    success: import("@sinclair/typebox").TBoolean;
+    target: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=SendMessage.d.ts.map

package/dist/tools/claude/SendMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SendMessage.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/SendMessage.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;GAkChC,CAAC"}

package/dist/tools/claude/SendMessage.js

@@ -0,0 +1,33 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+export const claudeSendMessageTool = defineTool({
+    name: "SendMessage",
+    label: "SendMessage",
+    description: "Send follow-up work to a previously spawned subagent by its task name, path, or agent id. The agent resumes with its full context preserved.",
+    arguments: Type.Object({
+        to: Type.String({ description: "The target subagent's task name, path, or agent id." }),
+        summary: Type.Optional(Type.String({ description: "A short human-readable summary of the follow-up." })),
+        message: Type.String({ description: "The follow-up instructions." }),
+    }),
+    returnType: Type.Object({
+        message: Type.String(),
+        success: Type.Boolean(),
+        target: Type.String(),
+    }),
+    execute: ({ message, summary, to }, context) => {
+        if (context.subagents === undefined) {
+            throw new Error("Subagent management is unavailable in this session.");
+        }
+        const target = context.subagents.followUp(to, message);
+        return {
+            message: summary === undefined
+                ? `Follow-up work was sent to ${target.description}.`
+                : `${summary}: follow-up work was sent to ${target.description}.`,
+            success: true,
+            target: target.path,
+        };
+    },
+    toLLM: (result) => [{ type: "text", text: JSON.stringify(result) }],
+    toUI: (result) => result.message,
+    locks: [],
+});

package/dist/tools/claude/TaskCreate.d.ts

@@ -0,0 +1,12 @@
+export declare const claudeTaskCreateTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    subject: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TString;
+    activeForm: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    metadata: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
+}>, import("@sinclair/typebox").TObject<{
+    task: import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        subject: import("@sinclair/typebox").TString;
+    }>;
+}>>;
+//# sourceMappingURL=TaskCreate.d.ts.map

package/dist/tools/claude/TaskCreate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskCreate.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/TaskCreate.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,oBAAoB;;;;;;;;;;GAoC/B,CAAC"}

package/dist/tools/claude/TaskCreate.js

@@ -0,0 +1,34 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { taskMetadataSchema } from "./taskSchemas.js";
+export const claudeTaskCreateTool = defineTool({
+    name: "TaskCreate",
+    label: "TaskCreate",
+    description: "Create a structured task for a non-trivial coding session. New tasks begin as pending.",
+    arguments: Type.Object({
+        subject: Type.String({ description: "A brief actionable title for the task." }),
+        description: Type.String({ description: "What needs to be done." }),
+        activeForm: Type.Optional(Type.String({ description: "Present-continuous text shown while in progress." })),
+        metadata: Type.Optional(taskMetadataSchema),
+    }, { additionalProperties: false }),
+    returnType: Type.Object({
+        task: Type.Object({ id: Type.String(), subject: Type.String() }),
+    }),
+    execute({ subject, description, activeForm, metadata }, context) {
+        if (context.tasks === undefined) {
+            throw new Error("Task tracking is unavailable in this session.");
+        }
+        const task = context.tasks.create({
+            subject,
+            description,
+            ...(activeForm !== undefined ? { activeForm } : {}),
+            ...(metadata !== undefined ? { metadata } : {}),
+        });
+        return { task: { id: task.id, subject: task.subject } };
+    },
+    toLLM: ({ task }) => [
+        { type: "text", text: `Task #${task.id} created successfully: ${task.subject}` },
+    ],
+    toUI: ({ task }) => `Created task: ${task.subject}`,
+    locks: ["tasks"],
+});

package/dist/tools/claude/TaskGet.d.ts

@@ -0,0 +1,16 @@
+export declare const claudeTaskGetTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    taskId: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    task: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        subject: import("@sinclair/typebox").TString;
+        description: import("@sinclair/typebox").TString;
+        activeForm: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        owner: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"in_progress">, import("@sinclair/typebox").TLiteral<"completed">]>;
+        blocks: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        blockedBy: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        metadata: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
+    }>, import("@sinclair/typebox").TNull]>;
+}>>;
+//# sourceMappingURL=TaskGet.d.ts.map

package/dist/tools/claude/TaskGet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskGet.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/TaskGet.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;GA0C5B,CAAC"}

package/dist/tools/claude/TaskGet.js

@@ -0,0 +1,44 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { sessionTaskSchema } from "./taskSchemas.js";
+export const claudeTaskGetTool = defineTool({
+    name: "TaskGet",
+    label: "TaskGet",
+    description: "Get the full details and dependencies for a task by its ID.",
+    arguments: Type.Object({ taskId: Type.String({ description: "The ID of the task to retrieve." }) }, { additionalProperties: false }),
+    returnType: Type.Object({ task: Type.Union([sessionTaskSchema, Type.Null()]) }),
+    execute({ taskId }, context) {
+        if (context.tasks === undefined) {
+            throw new Error("Task tracking is unavailable in this session.");
+        }
+        const task = context.tasks.get(taskId);
+        return {
+            task: task === undefined
+                ? null
+                : {
+                    ...task,
+                    blockedBy: [...task.blockedBy],
+                    blocks: [...task.blocks],
+                    ...(task.metadata !== undefined
+                        ? { metadata: { ...task.metadata } }
+                        : {}),
+                },
+        };
+    },
+    toLLM: ({ task }) => {
+        if (task === null)
+            return [{ type: "text", text: "Task not found" }];
+        const lines = [
+            `Task #${task.id}: ${task.subject}`,
+            `Status: ${task.status}`,
+            `Description: ${task.description}`,
+        ];
+        if (task.blockedBy.length > 0)
+            lines.push(`Blocked by: ${task.blockedBy.join(", ")}`);
+        if (task.blocks.length > 0)
+            lines.push(`Blocks: ${task.blocks.join(", ")}`);
+        return [{ type: "text", text: lines.join("\n") }];
+    },
+    toUI: ({ task }, { taskId }) => task === null ? `Task ${taskId} was not found` : `Read task: ${task.subject}`,
+    locks: [],
+});

package/dist/tools/claude/TaskList.d.ts

@@ -0,0 +1,10 @@
+export declare const claudeTaskListTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{}>, import("@sinclair/typebox").TObject<{
+    tasks: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        subject: import("@sinclair/typebox").TString;
+        status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"in_progress">, import("@sinclair/typebox").TLiteral<"completed">]>;
+        owner: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        blockedBy: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    }>>;
+}>>;
+//# sourceMappingURL=TaskList.d.ts.map

package/dist/tools/claude/TaskList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskList.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/TaskList.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,kBAAkB;;;;;;;;GA4C7B,CAAC"}

package/dist/tools/claude/TaskList.js

@@ -0,0 +1,51 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { taskStatusSchema } from "./taskSchemas.js";
+const taskSummarySchema = Type.Object({
+    id: Type.String(),
+    subject: Type.String(),
+    status: taskStatusSchema,
+    owner: Type.Optional(Type.String()),
+    blockedBy: Type.Array(Type.String()),
+});
+export const claudeTaskListTool = defineTool({
+    name: "TaskList",
+    label: "TaskList",
+    description: "List all tasks with their status, owner, and unresolved dependencies.",
+    arguments: Type.Object({}, { additionalProperties: false }),
+    returnType: Type.Object({ tasks: Type.Array(taskSummarySchema) }),
+    execute(_args, context) {
+        if (context.tasks === undefined) {
+            throw new Error("Task tracking is unavailable in this session.");
+        }
+        const tasks = context.tasks.list();
+        const completed = new Set(tasks.filter((task) => task.status === "completed").map((task) => task.id));
+        return {
+            tasks: tasks.map((task) => ({
+                id: task.id,
+                subject: task.subject,
+                status: task.status,
+                ...(task.owner !== undefined ? { owner: task.owner } : {}),
+                blockedBy: task.blockedBy.filter((taskId) => !completed.has(taskId)),
+            })),
+        };
+    },
+    toLLM: ({ tasks }) => [
+        {
+            type: "text",
+            text: tasks.length === 0
+                ? "No tasks found"
+                : tasks
+                    .map((task) => {
+                    const owner = task.owner === undefined ? "" : ` (${task.owner})`;
+                    const blocked = task.blockedBy.length === 0
+                        ? ""
+                        : ` [blocked by ${task.blockedBy.join(", ")}]`;
+                    return `#${task.id} [${task.status}] ${task.subject}${owner}${blocked}`;
+                })
+                    .join("\n"),
+        },
+    ],
+    toUI: ({ tasks }) => `Listed ${tasks.length} task${tasks.length === 1 ? "" : "s"}`,
+    locks: [],
+});

package/dist/tools/claude/TaskOutput.d.ts

@@ -0,0 +1,17 @@
+export declare const claudeTaskOutputTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    task_id: import("@sinclair/typebox").TString;
+    block: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    retrieval_status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"not_ready">, import("@sinclair/typebox").TLiteral<"success">, import("@sinclair/typebox").TLiteral<"timeout">]>;
+    task: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        command: import("@sinclair/typebox").TString;
+        description: import("@sinclair/typebox").TString;
+        exitCode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TNull]>>;
+        output: import("@sinclair/typebox").TString;
+        status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"completed">, import("@sinclair/typebox").TLiteral<"killed">, import("@sinclair/typebox").TLiteral<"running">]>;
+        task_id: import("@sinclair/typebox").TString;
+        task_type: import("@sinclair/typebox").TLiteral<"local_bash">;
+    }>, import("@sinclair/typebox").TNull]>;
+}>>;
+//# sourceMappingURL=TaskOutput.d.ts.map

package/dist/tools/claude/TaskOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskOutput.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/TaskOutput.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;GA6D/B,CAAC"}

package/dist/tools/claude/TaskOutput.js

@@ -0,0 +1,74 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { readSessionWithProgress } from "../utils/readSessionWithProgress.js";
+import { parseBackgroundTaskId } from "./parseBackgroundTaskId.js";
+const backgroundTaskSchema = Type.Object({
+    command: Type.String(),
+    description: Type.String(),
+    exitCode: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    output: Type.String(),
+    status: Type.Union([
+        Type.Literal("completed"),
+        Type.Literal("killed"),
+        Type.Literal("running"),
+    ]),
+    task_id: Type.String(),
+    task_type: Type.Literal("local_bash"),
+});
+export const claudeTaskOutputTool = defineTool({
+    name: "TaskOutput",
+    label: "TaskOutput",
+    description: "Read output from a running or completed background shell task.",
+    arguments: Type.Object({
+        task_id: Type.String({ description: "The background task identifier." }),
+        block: Type.Optional(Type.Boolean({ description: "Whether to wait for the task to finish." })),
+        timeout: Type.Optional(Type.Number({
+            description: "Maximum wait in milliseconds.",
+            maximum: 600_000,
+            minimum: 0,
+        })),
+    }),
+    returnType: Type.Object({
+        retrieval_status: Type.Union([
+            Type.Literal("not_ready"),
+            Type.Literal("success"),
+            Type.Literal("timeout"),
+        ]),
+        task: Type.Union([backgroundTaskSchema, Type.Null()]),
+    }),
+    execute: async ({ block = true, task_id, timeout = 30_000 }, context, execution) => {
+        const sessionId = parseBackgroundTaskId(task_id);
+        const snapshot = await readSessionWithProgress({
+            bash: context.bash,
+            ...(execution.onProgress === undefined ? {} : { onProgress: execution.onProgress }),
+            sessionId,
+            ...(execution.signal === undefined ? {} : { signal: execution.signal }),
+            waitMs: block ? timeout : 0,
+        });
+        if (snapshot === undefined) {
+            throw new Error("The background task was not found.");
+        }
+        const stillRunning = snapshot.status === "running";
+        return {
+            retrieval_status: stillRunning ? (block ? "timeout" : "not_ready") : "success",
+            task: {
+                command: snapshot.command,
+                description: snapshot.command,
+                ...(stillRunning ? {} : { exitCode: snapshot.exitCode }),
+                output: [snapshot.stdout, snapshot.stderr]
+                    .filter((value) => value.length > 0)
+                    .join("\n"),
+                status: snapshot.status,
+                task_id,
+                task_type: "local_bash",
+            },
+        };
+    },
+    toLLM: (result) => [{ type: "text", text: JSON.stringify(result) }],
+    toUI: (result) => result.retrieval_status === "success"
+        ? "Background command output is ready."
+        : result.retrieval_status === "timeout"
+            ? "Background command is still running after the wait."
+            : "Background command is still running.",
+    locks: [],
+});