@withakay/opencode-autopilot 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,164 +1,201 @@
-// state/session-cache.ts
-function createSessionStore() {
-  return {
-    roles: new Map,
-    agents: new Map,
-    textParts: new Map
-  };
-}
-
-class SessionCache {
-  sessions = new Map;
-  ensureSession(sessionID) {
-    const existing = this.sessions.get(sessionID);
-    if (existing) {
-      return existing;
+// hooks/chat-message.ts
+var CONTROL_AGENT = "autopilot";
+function createChatMessageHook(deps) {
+  const { getState, incrementSuppressCount } = deps;
+  return async (input, _output) => {
+    const state = getState(input.sessionID);
+    if (!state || state.mode !== "ENABLED") {
+      return;
     }
-    const created = createSessionStore();
-    this.sessions.set(sessionID, created);
-    return created;
-  }
-  setRole(sessionID, messageID, role) {
-    this.ensureSession(sessionID).roles.set(messageID, role);
-  }
-  getRole(sessionID, messageID) {
-    return this.sessions.get(sessionID)?.roles.get(messageID) ?? null;
-  }
-  setAgent(sessionID, messageID, agent) {
-    this.ensureSession(sessionID).agents.set(messageID, agent);
-  }
-  getAgent(sessionID, messageID) {
-    return this.sessions.get(sessionID)?.agents.get(messageID) ?? null;
-  }
-  setTextPart(sessionID, partID, messageID, text) {
-    this.ensureSession(sessionID).textParts.set(partID, {
-      id: partID,
-      messageID,
-      text
-    });
-  }
-  getTextPart(sessionID, partID) {
-    return this.sessions.get(sessionID)?.textParts.get(partID) ?? null;
-  }
-  getMessageText(sessionID, messageID) {
-    const session = this.sessions.get(sessionID);
-    if (!session) {
-      return "";
+    if (input.agent === CONTROL_AGENT) {
+      incrementSuppressCount(input.sessionID);
     }
-    return [...session.textParts.values()].filter((part) => part.messageID === messageID).map((part) => part.text).join("");
-  }
-  snapshot(sessionID) {
-    const session = this.sessions.get(sessionID) ?? createSessionStore();
-    return {
-      roles: Object.fromEntries(session.roles),
-      agents: Object.fromEntries(session.agents),
-      textParts: [...session.textParts.values()]
-    };
-  }
-  cleanup(sessionID) {
-    this.sessions.delete(sessionID);
-  }
+  };
 }
 
-// state/factory.ts
-var DEFAULT_ALLOWED_TOOLS = ["bash", "read", "glob", "grep", "apply_patch"];
-var DEFAULT_CONTEXT_THRESHOLD = 8000;
-var DEFAULT_MAX_CONTINUES = 25;
-var DEFAULT_MAX_STEP_RETRIES = 2;
-var DEFAULT_MAX_GLOBAL_RETRIES = 6;
-var DEFAULT_MAX_NO_PROGRESS = 3;
-var DEFAULT_WORKER_AGENT = "pi";
-function createPlanState() {
+// hooks/event-handler.ts
+function createSessionTracking() {
   return {
-    steps: [],
-    open_items: [],
-    completed_items: [],
-    blocked_items: [],
-    dependencies: {},
-    stale: false
+    lastAssistantMessageID: undefined,
+    lastUsage: undefined,
+    awaitingWorkerReply: false,
+    blockedByPermission: false,
+    permissionBlockMessage: undefined
   };
 }
-function createApprovalState() {
-  return {
-    status: "idle",
-    pending_action: null,
-    pending_scope: null,
-    approved_scopes: [],
-    denied_scopes: [],
-    last_feedback: null
-  };
+function isString(value) {
+  return typeof value === "string";
 }
-function createTrustState(trustedPaths) {
-  return {
-    status: trustedPaths.length > 0 ? "trusted" : "untrusted",
-    trusted_paths: [...trustedPaths],
-    pending_path: null,
-    denied_paths: [],
-    last_feedback: null
-  };
+function isObject(value) {
+  return typeof value === "object" && value !== null;
 }
-function createContextState(remainingBudget, threshold) {
-  const resolvedBudget = remainingBudget ?? null;
-  const compactionNeeded = resolvedBudget !== null ? resolvedBudget <= threshold : false;
-  return {
-    remaining_budget: resolvedBudget,
-    threshold,
-    compaction_needed: compactionNeeded,
-    compacted_at: null,
-    unsafe_to_continue: compactionNeeded
+function normalizeError(error) {
+  if (!isObject(error))
+    return;
+  const result = {};
+  if (isString(error.name)) {
+    result.name = error.name;
+  }
+  if (isObject(error.data) && isString(error.data.message)) {
+    result.data = { message: error.data.message };
+  }
+  return result;
+}
+function createEventHandler(deps) {
+  const { getState, deleteState, sessionCache, getTracking, onSessionIdle, onSessionError } = deps;
+  return async function handleEvent(input) {
+    const { event } = input;
+    switch (event.type) {
+      case "message.updated": {
+        const info = event.properties.info;
+        if (!isObject(info))
+          return;
+        const sessionID = info.sessionID;
+        const messageID = info.id;
+        const role = info.role;
+        if (!isString(sessionID) || !isString(messageID) || !isString(role)) {
+          return;
+        }
+        if (role === "user" || role === "assistant") {
+          sessionCache.setRole(sessionID, messageID, role);
+        }
+        if ("agent" in info && isString(info.agent)) {
+          sessionCache.setAgent(sessionID, messageID, info.agent);
+        }
+        if (role === "assistant") {
+          const state = getState(sessionID);
+          const tracking = getTracking(sessionID);
+          if (state && tracking?.awaitingWorkerReply) {
+            const agent = "agent" in info && isString(info.agent) ? info.agent : undefined;
+            if (agent === state.worker_agent) {
+              tracking.lastAssistantMessageID = messageID;
+              tracking.lastUsage = {
+                tokens: info.tokens,
+                cost: info.cost
+              };
+            }
+          }
+        }
+        return;
+      }
+      case "message.part.updated": {
+        const part = event.properties.part;
+        if (!isObject(part))
+          return;
+        if (part.type !== "text" || !isString(part.sessionID) || !isString(part.messageID) || !isString(part.id) || !isString(part.text)) {
+          return;
+        }
+        const state = getState(part.sessionID);
+        if (!state)
+          return;
+        const cachedRole = sessionCache.getRole(part.sessionID, part.messageID);
+        const cachedAgent = sessionCache.getAgent(part.sessionID, part.messageID);
+        if (cachedRole === "assistant" && cachedAgent === state.worker_agent) {
+          sessionCache.setTextPart(part.sessionID, part.id, part.messageID, part.text);
+        }
+        return;
+      }
+      case "session.idle": {
+        const sessionID = event.properties.sessionID;
+        if (!isString(sessionID))
+          return;
+        await onSessionIdle(sessionID);
+        return;
+      }
+      case "session.error": {
+        const sessionID = event.properties.sessionID;
+        if (!isString(sessionID))
+          return;
+        const state = getState(sessionID);
+        if (!state || state.mode !== "ENABLED")
+          return;
+        const error = normalizeError(event.properties.error);
+        await onSessionError(sessionID, error);
+        return;
+      }
+      case "session.deleted": {
+        const info = event.properties.info;
+        if (!isObject(info) || !isString(info.id))
+          return;
+        sessionCache.cleanup(info.id);
+        deleteState(info.id);
+        return;
+      }
+      case "permission.updated": {
+        const sessionID = event.properties.sessionID;
+        if (!isString(sessionID))
+          return;
+        const state = getState(sessionID);
+        const tracking = getTracking(sessionID);
+        if (!state || state.mode !== "ENABLED" || !tracking)
+          return;
+        tracking.blockedByPermission = true;
+        const permType = isString(event.properties.type) ? event.properties.type : "unknown";
+        const patterns = event.properties.pattern;
+        const patternStr = Array.isArray(patterns) ? patterns.filter(isString).join(", ") : isString(patterns) ? patterns : "";
+        tracking.permissionBlockMessage = `Denied ${permType} ${patternStr}`.trim();
+        return;
+      }
+    }
   };
 }
-function createRetryCounters(options) {
-  return {
-    step_retry_count: 0,
-    global_retry_count: 0,
-    no_progress_count: 0,
-    recovery_attempt_count: 0,
-    max_step_retries: options.maxStepRetries ?? DEFAULT_MAX_STEP_RETRIES,
-    max_global_retries: options.maxGlobalRetries ?? DEFAULT_MAX_GLOBAL_RETRIES,
-    max_no_progress: options.maxNoProgress ?? DEFAULT_MAX_NO_PROGRESS
+
+// hooks/permission.ts
+function createPermissionHook(deps) {
+  return async (input, output) => {
+    const state = deps.getState(input.sessionID);
+    if (!state || state.mode !== "ENABLED") {
+      return;
+    }
+    const permissionMode = deps.getPermissionMode(input.sessionID);
+    if (permissionMode === "allow-all") {
+      output.status = "allow";
+      return;
+    }
+    if (permissionMode === "limited") {
+      output.status = "deny";
+      deps.onPermissionDenied?.(input.sessionID, {
+        type: input.type,
+        pattern: input.pattern,
+        title: input.title
+      });
+    }
   };
 }
-function createInitialState(goal, options = {}) {
-  const sessionID = options.sessionID ?? "";
-  const allowedPaths = options.allowedPaths ?? [];
-  return {
-    session_id: sessionID,
-    mode: options.mode ?? "DISABLED",
-    phase: options.phase ?? "STOPPED",
-    goal,
-    plan_state: createPlanState(),
-    completion_evidence: [],
-    allowed_tools: [...options.allowedTools ?? DEFAULT_ALLOWED_TOOLS],
-    allowed_paths: [...allowedPaths],
-    approval_state: createApprovalState(),
-    trust_state: createTrustState(options.trustedPaths ?? allowedPaths),
-    context_state: createContextState(options.remainingBudget ?? null, options.contextThreshold ?? DEFAULT_CONTEXT_THRESHOLD),
-    foreground_action: null,
-    background_tasks: [],
-    retry_counters: createRetryCounters(options),
-    stop_reason: null,
-    latest_observations: {
-      events: [],
-      last_user_input: null,
-      last_tool_result: null,
-      last_tool_error: null,
-      last_interrupt: null
-    },
-    continuation_count: 0,
-    max_continues: options.maxContinues ?? DEFAULT_MAX_CONTINUES,
-    worker_agent: options.workerAgent ?? DEFAULT_WORKER_AGENT,
-    last_updated_at: null,
-    resumable: true
+
+// hooks/system-transform.ts
+function createSystemTransformHook(deps) {
+  const { getState, getSuppressCount, decrementSuppressCount, buildSystemPrompt } = deps;
+  return async (input, output) => {
+    const { sessionID } = input;
+    if (sessionID === undefined) {
+      return;
+    }
+    const state = getState(sessionID);
+    if (!state || state.mode !== "ENABLED") {
+      return;
+    }
+    const suppressCount = getSuppressCount(sessionID);
+    if (suppressCount > 0) {
+      decrementSuppressCount(sessionID);
+      return;
+    }
+    if (!Array.isArray(output.system)) {
+      output.system = [];
+    }
+    output.system.push(buildSystemPrompt(state.autonomous_strength));
   };
 }
-function createSessionState(sessionID, goal, options = {}) {
-  return createInitialState(goal, {
-    ...options,
-    sessionID,
-    mode: options.mode ?? "ENABLED",
-    phase: options.phase ?? "OBSERVE"
-  });
+
+// hooks/tool-after.ts
+var AUTOPILOT_TOOL = "autopilot";
+function createToolAfterHook(deps) {
+  return async (input, output) => {
+    if (input.tool !== AUTOPILOT_TOOL) {
+      return;
+    }
+    output.output = deps.stripMarker(output.output);
+  };
 }
 
 // prompts/continuation.ts
@@ -262,9 +299,13 @@ function summarizeAutopilotState(state) {
   const status = [
     `phase=${state.phase}`,
     `mode=${state.mode}`,
+    `session_mode=${state.session_mode}`,
     `continues=${state.continuation_count}/${state.max_continues}`,
     `agent=${state.worker_agent}`
   ];
+  if (state.session_mode === "delegated-task") {
+    status.push(`task=${JSON.stringify(state.goal)}`);
+  }
   if (state.stop_reason) {
     status.push(`stop=${state.stop_reason}`);
   }
@@ -285,277 +326,298 @@ function normalizeMaxContinues(value) {
   return Math.min(AUTOPILOT_MAX_CONTINUES_HARD_LIMIT, Math.max(1, Math.floor(numeric)));
 }
 // prompts/system-prompt.ts
-function buildAutopilotSystemPrompt() {
-  return [
-    "Autopilot mode is active for this session.",
-    "Work autonomously toward the user's goal without asking follow-up questions unless you are truly blocked.",
+function buildAutopilotSystemPrompt(strength = "balanced") {
+  const baseInstructions = ["Autopilot mode is active for this session."];
+  const behaviorInstructions = (() => {
+    switch (strength) {
+      case "conservative":
+        return [
+          "Work autonomously toward the user's goal and ask fewer follow-up questions.",
+          "Prefer the recommended or safest reasonable default when a routine choice is needed.",
+          "Only ask the user for input when you are truly blocked, the choice is high-impact, or no safe default exists."
+        ];
+      case "balanced":
+        return [
+          "Work autonomously toward the user's goal with minimal user interaction.",
+          "When faced with routine choices (file paths, variable names, standard configurations), select the recommended or safest default without asking.",
+          "Only escalate to the user for: (1) high-impact decisions, (2) security/safety risks, or (3) when truly blocked with no reasonable default."
+        ];
+      case "aggressive":
+        return [
+          "CRITICAL: Work with maximum autonomy. Minimize all user interaction.",
+          "When faced with any routine choice (file paths, variable names, configurations, formatting preferences), ALWAYS select the recommended or safest default immediately. DO NOT ask the user.",
+          "For choices with a 'recommended' option clearly marked, select it automatically and explain your choice in the response.",
+          "Only escalate to the user for: (1) high-impact irreversible decisions (data deletion, major refactors), (2) explicit user preference required (UX/design choices affecting end users), or (3) security/safety risks.",
+          "If you can make reasonable progress on a task without user input, do so immediately."
+        ];
+    }
+  })();
+  const statusMarkerInstructions = [
+    "If a delegated autopilot task is in progress, keep it moving without waiting for extra confirmation.",
     "At the very end of every assistant response, append exactly one machine-readable status marker on its own line using this format:",
     '<autopilot status="continue|complete|blocked">short reason</autopilot>',
     "Use continue when more work remains and you can keep going without the user.",
     "Use complete when the task is done or you have reached a stable handoff point.",
     "Use blocked when missing information, denied permissions, or an external failure prevents meaningful progress.",
     "Do not omit the marker."
-  ].join(`
+  ];
+  return [...baseInstructions, ...behaviorInstructions, ...statusMarkerInstructions].join(`
 `);
 }
-// hooks/event-handler.ts
-function createSessionTracking() {
+// state/factory.ts
+var DEFAULT_ALLOWED_TOOLS = ["bash", "read", "glob", "grep", "apply_patch"];
+var DEFAULT_CONTEXT_THRESHOLD = 8000;
+var DEFAULT_MAX_CONTINUES = 25;
+var DEFAULT_MAX_STEP_RETRIES = 2;
+var DEFAULT_MAX_GLOBAL_RETRIES = 6;
+var DEFAULT_MAX_NO_PROGRESS = 3;
+var DEFAULT_WORKER_AGENT = "pi";
+var DEFAULT_AUTONOMOUS_STRENGTH = "balanced";
+function createPlanState() {
   return {
-    lastAssistantMessageID: undefined,
-    lastUsage: undefined,
-    awaitingWorkerReply: false,
-    blockedByPermission: false,
-    permissionBlockMessage: undefined
+    steps: [],
+    open_items: [],
+    completed_items: [],
+    blocked_items: [],
+    dependencies: {},
+    stale: false
   };
 }
-function isString(value) {
-  return typeof value === "string";
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function normalizeError(error) {
-  if (!isObject(error))
-    return;
-  const result = {};
-  if (isString(error["name"])) {
-    result.name = error["name"];
-  }
-  if (isObject(error["data"]) && isString(error["data"]["message"])) {
-    result.data = { message: error["data"]["message"] };
-  }
-  return result;
-}
-function createEventHandler(deps) {
-  const {
-    getState,
-    deleteState,
-    sessionCache,
-    getTracking,
-    onSessionIdle,
-    onSessionError
-  } = deps;
-  return async function handleEvent(input) {
-    const { event } = input;
-    switch (event.type) {
-      case "message.updated": {
-        const info = event.properties["info"];
-        if (!isObject(info))
-          return;
-        const sessionID = info["sessionID"];
-        const messageID = info["id"];
-        const role = info["role"];
-        if (!isString(sessionID) || !isString(messageID) || !isString(role)) {
-          return;
-        }
-        if (role === "user" || role === "assistant") {
-          sessionCache.setRole(sessionID, messageID, role);
-        }
-        if ("agent" in info && isString(info["agent"])) {
-          sessionCache.setAgent(sessionID, messageID, info["agent"]);
-        }
-        if (role === "assistant") {
-          const state = getState(sessionID);
-          const tracking = getTracking(sessionID);
-          if (state && tracking && tracking.awaitingWorkerReply) {
-            const agent = "agent" in info && isString(info["agent"]) ? info["agent"] : undefined;
-            if (agent === state.worker_agent) {
-              tracking.lastAssistantMessageID = messageID;
-              tracking.lastUsage = {
-                tokens: info["tokens"],
-                cost: info["cost"]
-              };
-            }
-          }
-        }
-        return;
-      }
-      case "message.part.updated": {
-        const part = event.properties["part"];
-        if (!isObject(part))
-          return;
-        if (part["type"] !== "text" || !isString(part["sessionID"]) || !isString(part["messageID"]) || !isString(part["id"]) || !isString(part["text"])) {
-          return;
-        }
-        const state = getState(part["sessionID"]);
-        if (!state)
-          return;
-        const cachedRole = sessionCache.getRole(part["sessionID"], part["messageID"]);
-        const cachedAgent = sessionCache.getAgent(part["sessionID"], part["messageID"]);
-        if (cachedRole === "assistant" && cachedAgent === state.worker_agent) {
-          sessionCache.setTextPart(part["sessionID"], part["id"], part["messageID"], part["text"]);
-        }
-        return;
-      }
-      case "session.idle": {
-        const sessionID = event.properties["sessionID"];
-        if (!isString(sessionID))
-          return;
-        await onSessionIdle(sessionID);
-        return;
-      }
-      case "session.error": {
-        const sessionID = event.properties["sessionID"];
-        if (!isString(sessionID))
-          return;
-        const state = getState(sessionID);
-        if (!state || state.mode !== "ENABLED")
-          return;
-        const error = normalizeError(event.properties["error"]);
-        await onSessionError(sessionID, error);
-        return;
-      }
-      case "session.deleted": {
-        const info = event.properties["info"];
-        if (!isObject(info) || !isString(info["id"]))
-          return;
-        sessionCache.cleanup(info["id"]);
-        deleteState(info["id"]);
-        return;
-      }
-      case "permission.updated": {
-        const sessionID = event.properties["sessionID"];
-        if (!isString(sessionID))
-          return;
-        const state = getState(sessionID);
-        const tracking = getTracking(sessionID);
-        if (!state || state.mode !== "ENABLED" || !tracking)
-          return;
-        tracking.blockedByPermission = true;
-        const permType = isString(event.properties["type"]) ? event.properties["type"] : "unknown";
-        const patterns = event.properties["pattern"];
-        const patternStr = Array.isArray(patterns) ? patterns.filter(isString).join(", ") : isString(patterns) ? patterns : "";
-        tracking.permissionBlockMessage = `Denied ${permType} ${patternStr}`.trim();
-        return;
-      }
-    }
+function createApprovalState() {
+  return {
+    status: "idle",
+    pending_action: null,
+    pending_scope: null,
+    approved_scopes: [],
+    denied_scopes: [],
+    last_feedback: null
+  };
+}
+function createTrustState(trustedPaths) {
+  return {
+    status: trustedPaths.length > 0 ? "trusted" : "untrusted",
+    trusted_paths: [...trustedPaths],
+    pending_path: null,
+    denied_paths: [],
+    last_feedback: null
   };
 }
-
-// hooks/permission.ts
-function createPermissionHook(deps) {
-  return async (input, output) => {
-    const state = deps.getState(input.sessionID);
-    if (!state || state.mode !== "ENABLED") {
-      return;
-    }
-    const permissionMode = deps.getPermissionMode(input.sessionID);
-    if (permissionMode === "allow-all") {
-      output.status = "allow";
-      return;
-    }
-    if (permissionMode === "limited") {
-      output.status = "deny";
-      deps.onPermissionDenied?.(input.sessionID, {
-        type: input.type,
-        pattern: input.pattern,
-        title: input.title
-      });
-    }
+function createContextState(remainingBudget, threshold) {
+  const resolvedBudget = remainingBudget ?? null;
+  const compactionNeeded = resolvedBudget === null ? false : resolvedBudget <= threshold;
+  return {
+    remaining_budget: resolvedBudget,
+    threshold,
+    compaction_needed: compactionNeeded,
+    compacted_at: null,
+    unsafe_to_continue: compactionNeeded
   };
 }
-
-// hooks/system-transform.ts
-function createSystemTransformHook(deps) {
-  const {
-    getState,
-    getSuppressCount,
-    decrementSuppressCount,
-    buildSystemPrompt
-  } = deps;
-  return async (input, output) => {
-    const { sessionID } = input;
-    if (sessionID === undefined) {
-      return;
-    }
-    const state = getState(sessionID);
-    if (!state || state.mode !== "ENABLED") {
-      return;
-    }
-    const suppressCount = getSuppressCount(sessionID);
-    if (suppressCount > 0) {
-      decrementSuppressCount(sessionID);
-      return;
-    }
-    if (!Array.isArray(output.system)) {
-      output.system = [];
-    }
-    output.system.push(buildSystemPrompt());
+function createRetryCounters(options) {
+  return {
+    step_retry_count: 0,
+    global_retry_count: 0,
+    no_progress_count: 0,
+    recovery_attempt_count: 0,
+    max_step_retries: options.maxStepRetries ?? DEFAULT_MAX_STEP_RETRIES,
+    max_global_retries: options.maxGlobalRetries ?? DEFAULT_MAX_GLOBAL_RETRIES,
+    max_no_progress: options.maxNoProgress ?? DEFAULT_MAX_NO_PROGRESS
+  };
+}
+function createInitialState(goal, options = {}) {
+  const sessionID = options.sessionID ?? "";
+  const allowedPaths = options.allowedPaths ?? [];
+  return {
+    session_id: sessionID,
+    mode: options.mode ?? "DISABLED",
+    phase: options.phase ?? "STOPPED",
+    session_mode: options.sessionMode ?? "delegated-task",
+    goal,
+    plan_state: createPlanState(),
+    completion_evidence: [],
+    allowed_tools: [...options.allowedTools ?? DEFAULT_ALLOWED_TOOLS],
+    allowed_paths: [...allowedPaths],
+    approval_state: createApprovalState(),
+    trust_state: createTrustState(options.trustedPaths ?? allowedPaths),
+    context_state: createContextState(options.remainingBudget ?? null, options.contextThreshold ?? DEFAULT_CONTEXT_THRESHOLD),
+    foreground_action: null,
+    background_tasks: [],
+    retry_counters: createRetryCounters(options),
+    stop_reason: null,
+    latest_observations: {
+      events: [],
+      last_user_input: null,
+      last_tool_result: null,
+      last_tool_error: null,
+      last_interrupt: null
+    },
+    continuation_count: 0,
+    max_continues: options.maxContinues ?? DEFAULT_MAX_CONTINUES,
+    worker_agent: options.workerAgent ?? DEFAULT_WORKER_AGENT,
+    autonomous_strength: options.autonomousStrength ?? DEFAULT_AUTONOMOUS_STRENGTH,
+    last_updated_at: null,
+    resumable: true
   };
 }
+function createSessionState(sessionID, goal, options = {}) {
+  return createInitialState(goal, {
+    ...options,
+    sessionID,
+    mode: options.mode ?? "ENABLED",
+    phase: options.phase ?? "OBSERVE",
+    sessionMode: options.sessionMode ?? "delegated-task"
+  });
+}
 
-// hooks/chat-message.ts
-var CONTROL_AGENT = "autopilot";
-function createChatMessageHook(deps) {
-  const { getState, incrementSuppressCount } = deps;
-  return async (input, _output) => {
-    const state = getState(input.sessionID);
-    if (!state || state.mode !== "ENABLED") {
-      return;
-    }
-    if (input.agent === CONTROL_AGENT) {
-      incrementSuppressCount(input.sessionID);
-    }
+// state/session-cache.ts
+function createSessionStore() {
+  return {
+    roles: new Map,
+    agents: new Map,
+    textParts: new Map
   };
 }
 
-// hooks/tool-after.ts
-var AUTOPILOT_STATUS_TOOL = "autopilot_status";
-function createToolAfterHook(deps) {
-  return async (input, output) => {
-    if (input.tool !== AUTOPILOT_STATUS_TOOL) {
-      return;
+class SessionCache {
+  sessions = new Map;
+  ensureSession(sessionID) {
+    const existing = this.sessions.get(sessionID);
+    if (existing) {
+      return existing;
     }
-    output.output = deps.stripMarker(output.output);
-  };
+    const created = createSessionStore();
+    this.sessions.set(sessionID, created);
+    return created;
+  }
+  setRole(sessionID, messageID, role) {
+    this.ensureSession(sessionID).roles.set(messageID, role);
+  }
+  getRole(sessionID, messageID) {
+    return this.sessions.get(sessionID)?.roles.get(messageID) ?? null;
+  }
+  setAgent(sessionID, messageID, agent) {
+    this.ensureSession(sessionID).agents.set(messageID, agent);
+  }
+  getAgent(sessionID, messageID) {
+    return this.sessions.get(sessionID)?.agents.get(messageID) ?? null;
+  }
+  setTextPart(sessionID, partID, messageID, text) {
+    this.ensureSession(sessionID).textParts.set(partID, {
+      id: partID,
+      messageID,
+      text
+    });
+  }
+  getTextPart(sessionID, partID) {
+    return this.sessions.get(sessionID)?.textParts.get(partID) ?? null;
+  }
+  getMessageText(sessionID, messageID) {
+    const session = this.sessions.get(sessionID);
+    if (!session) {
+      return "";
+    }
+    return [...session.textParts.values()].filter((part) => part.messageID === messageID).map((part) => part.text).join("");
+  }
+  snapshot(sessionID) {
+    const session = this.sessions.get(sessionID) ?? createSessionStore();
+    return {
+      roles: Object.fromEntries(session.roles),
+      agents: Object.fromEntries(session.agents),
+      textParts: [...session.textParts.values()]
+    };
+  }
+  cleanup(sessionID) {
+    this.sessions.delete(sessionID);
+  }
 }
 
-// tools/start.ts
+// tools/autopilot.ts
 import { tool } from "@opencode-ai/plugin";
-var AUTOPILOT_FALLBACK_AGENT = "pi";
-function createStartTool(deps) {
-  return tool({
-    description: "Arm autopilot mode for the current session",
-    args: {
-      task: tool.schema.string().min(1).describe("Task for the autonomous worker to execute"),
-      permissionMode: tool.schema.enum(["limited", "allow-all"]).optional().describe("How permissions should behave while autopilot is active"),
-      maxContinues: tool.schema.number().int().positive().optional().describe("Maximum number of autonomous continuation prompts after the initial task prompt"),
-      workerAgent: tool.schema.string().optional().describe("Agent used for autonomous follow-up turns (defaults to pi)")
-    },
-    async execute(args, context) {
-      if (args.task.trim().toLowerCase() === "help") {
-        return `
-## Autopilot Usage
 
-Use the global \`Autopilot\` agent to control the autopilot plugin.
-
-**Start Autopilot:**
-Switch to the \`Autopilot\` agent, then send the task you want delegated.
-
-Examples:
-- \`Fix the failing tests\`
-- \`Use allow-all mode and build-high to refactor the reducer\`
+// tools/usage.ts
+function buildAutopilotUsage() {
+  return `
+## Autopilot Usage
 
-**Check Status:**
-- \`status\`
-- \`is autopilot running?\`
+Primary workflow:
+- \`/autopilot on\` — enable session autopilot defaults
+- \`/autopilot off\` — disable autopilot for this session
+- \`/autopilot status\` — show current status and recent events
+- \`/autopilot <task>\` — enable autopilot and hand a long-running task to the delegate agent
 
-**Stop Autopilot:**
-- \`stop\`
-- \`stop because I want to inspect manually\`
+Direct tool equivalents:
+- \`autopilot(action="on")\`
+- \`autopilot(action="off")\`
+- \`autopilot(action="status")\`
+- \`autopilot(task="Fix the failing tests")\`
+- \`autopilot(action="on", autonomousStrength="aggressive")\`
 
 Defaults:
 - permission mode: \`limited\`
 - continuation limit: \`10\`
-- worker agent: \`pi\`
-`.trim();
+- delegate agent: \`general\`
+- autonomous strength: \`balanced\`
+
+Autonomous strength modes:
+- \`conservative\` — soft guidance to prefer defaults, asks when unsure (similar to previous behavior)
+- \`balanced\` — stronger bias toward selecting recommended/safe defaults, minimal user interaction (default)
+- \`aggressive\` — always pick recommended/safe defaults for routine choices, only escalate high-impact decisions
+
+Notes:
+- Session autopilot makes OpenCode act more autonomously and ask fewer questions based on the configured autonomous strength.
+- Long-running delegated tasks run through the configured agent and continue until complete, blocked, or the continuation limit is reached.
+- OpenCode does not currently expose a general question-timeout hook, so autopilot can only auto-handle permission prompts directly. For everything else, the injected system guidance tells the active agent to prefer recommended defaults when safe. The autonomous strength parameter controls how strongly this guidance is worded.
+  `.trim();
+}
+
+// tools/autopilot.ts
+var AUTOPILOT_FALLBACK_AGENT = "pi";
+function createAutopilotTool(deps) {
+  return tool({
+    description: "Control session autopilot: turn it on or off, check status, or start a long-running delegated task",
+    args: {
+      action: tool.schema.enum(["on", "off", "status", "help"]).optional().describe("Autopilot command: on, off, status, or help"),
+      task: tool.schema.string().optional().describe("Optional delegated task to hand to the configured agent"),
+      permissionMode: tool.schema.enum(["limited", "allow-all"]).optional().describe("How permissions should behave while autopilot is active"),
+      maxContinues: tool.schema.number().int().positive().optional().describe("Maximum number of autonomous continuation prompts"),
+      workerAgent: tool.schema.string().optional().describe("Delegate agent used for long-running autopilot tasks"),
+      autonomousStrength: tool.schema.enum(["conservative", "balanced", "aggressive"]).optional().describe("How strongly autopilot prefers defaults: conservative (soft guidance), balanced (default, stronger guidance), aggressive (always pick recommended/safe defaults)")
+    },
+    async execute(args, context) {
+      const task = args.task?.trim() ?? "";
+      const action = args.action ?? (task ? "on" : "help");
+      if (action === "help" || !args.action && task.toLowerCase() === "help") {
+        return buildAutopilotUsage();
+      }
+      if (action === "status") {
+        const state2 = deps.getState(context.sessionID);
+        if (!state2) {
+          return deps.summarizeState(state2);
+        }
+        const history = deps.getHistory(context.sessionID);
+        const historyStr = history.length > 0 ? `
+Recent events:
+- ${history.join(`
+- `)}` : "";
+        return `${deps.summarizeState(state2)}${historyStr}`;
+      }
+      if (action === "off") {
+        const state2 = deps.getState(context.sessionID);
+        if (!state2 || state2.mode !== "ENABLED") {
+          return "Autopilot is not running in this session.";
+        }
+        deps.onStop(context.sessionID, task || undefined);
+        return task ? `Autopilot stopped: ${task}` : "Autopilot stopped for this session.";
       }
       const permissionMode = args.permissionMode ?? "limited";
       const maxContinues = deps.normalizeMaxContinues(args.maxContinues);
       const workerAgent = args.workerAgent?.trim() || deps.defaultWorkerAgent || AUTOPILOT_FALLBACK_AGENT;
-      const state = deps.createSessionState(context.sessionID, args.task.trim(), {
+      const autonomousStrength = args.autonomousStrength ?? "balanced";
+      const state = deps.createSessionState(context.sessionID, task, {
         maxContinues,
-        workerAgent
+        workerAgent,
+        autonomousStrength,
+        sessionMode: task ? "delegated-task" : "session-defaults"
       });
       Object.defineProperty(state, "permissionMode", {
         value: permissionMode,
@@ -566,103 +628,29 @@ Defaults:
       deps.setState(context.sessionID, state);
       deps.initSession(context.sessionID);
       context.metadata({
-        title: "Autopilot armed",
+        title: task ? "Autopilot task started" : "Autopilot enabled",
         metadata: {
+          action,
           permissionMode,
           maxContinues,
-          workerAgent
+          workerAgent,
+          autonomousStrength,
+          task: task || null
         }
       });
       await deps.onArmed(context.sessionID, state);
-      return `Autopilot armed in ${permissionMode} mode with ${workerAgent}. It will start after this response and may continue up to ${maxContinues} times.`;
-    }
-  });
-}
-
-// tools/status.ts
-import { tool as tool2 } from "@opencode-ai/plugin";
-function createStatusTool(deps) {
-  return tool2({
-    description: "Show autopilot status for the current session",
-    args: {},
-    async execute(_args, context) {
-      const state = deps.getState(context.sessionID);
-      if (!state) {
-        return deps.summarizeState(state);
-      }
-      const history = deps.getHistory(context.sessionID);
-      const historyStr = history.length > 0 ? `
-Recent events:
-- ${history.join(`
-- `)}` : "";
-      return `${deps.summarizeState(state)}${historyStr}`;
-    }
-  });
-}
-
-// tools/stop.ts
-import { tool as tool3 } from "@opencode-ai/plugin";
-function createStopTool(deps) {
-  return tool3({
-    description: "Stop autopilot mode for the current session",
-    args: {
-      reason: tool3.schema.string().optional().describe("Optional reason to include in the stop message")
-    },
-    async execute(args, context) {
-      const state = deps.getState(context.sessionID);
-      if (!state || state.mode !== "ENABLED") {
-        return "Autopilot is not running in this session.";
+      if (state.session_mode === "session-defaults") {
+        return `Autopilot is enabled in ${permissionMode} mode for this session. OpenCode will prefer reasonable defaults, ask fewer questions, and keep using ${workerAgent} for delegated work when you hand it a task.`;
       }
-      deps.onStop(context.sessionID, args.reason);
-      return args.reason ? `Autopilot stopped: ${args.reason}` : "Autopilot stopped for this session.";
-    }
-  });
-}
-
-// tools/help.ts
-import { tool as tool4 } from "@opencode-ai/plugin";
-function createHelpTool() {
-  return tool4({
-    description: "Show autopilot usage instructions",
-    args: {},
-    execute: async () => {
-      return `
-## Autopilot Usage
-
-Use the global \`Autopilot\` agent to control the autopilot plugin.
-
-**Start Autopilot:**
-Switch to the \`Autopilot\` agent, then send the task you want delegated.
-
-Examples:
-- \`Fix the failing tests\`
-- \`Use allow-all mode and build-high to refactor the reducer\`
-
-**Check Status:**
-- \`status\`
-- \`is autopilot running?\`
-
-**Stop Autopilot:**
-- \`stop\`
-- \`stop because I want to inspect manually\`
-
-Defaults:
-- permission mode: \`limited\`
-- continuation limit: \`10\`
-- worker agent: \`pi\`
-`.trim();
+      return `Autopilot enabled in ${permissionMode} mode with ${workerAgent}. It will start the delegated task after this response and may continue up to ${maxContinues} times.`;
     }
   });
 }
 
 // plugin.ts
-var AUTOPILOT_FALLBACK_AGENT2 = "pi";
+var AUTOPILOT_FALLBACK_AGENT2 = "general";
 var MAX_HISTORY_ENTRIES = 10;
-var AutopilotPlugin = async ({
-  client,
-  directory,
-  worktree
-}) => {
+var AutopilotPlugin = async ({ client, directory, worktree }) => {
   const stateBySession = new Map;
   const trackingBySession = new Map;
   const suppressCountBySession = new Map;
@@ -700,12 +688,12 @@ var AutopilotPlugin = async ({
   const safeToast = async (opts) => {
     try {
       await client.tui.showToast({
-        directory,
-        workspace: worktree,
-        title: opts.title,
-        message: opts.message,
-        variant: opts.variant,
-        duration: 3000
+        body: {
+          title: opts.title,
+          message: opts.message,
+          variant: opts.variant,
+          duration: 3000
+        }
       });
     } catch {}
   };
@@ -744,7 +732,7 @@ var AutopilotPlugin = async ({
     const tracking = getTracking(sessionID);
     if (!state || state.mode !== "ENABLED" || !tracking)
       return;
-    if (state.phase === "OBSERVE" && state.continuation_count === 0 && !tracking.lastAssistantMessageID) {
+    if (state.phase === "OBSERVE" && state.continuation_count === 0 && !tracking.lastAssistantMessageID && state.session_mode === "delegated-task") {
       recordHistory(sessionID, `Starting task with ${state.worker_agent}`);
       await safeToast({
         title: "Autopilot armed",
@@ -841,48 +829,44 @@ var AutopilotPlugin = async ({
   const toolAfterHook = createToolAfterHook({
     stripMarker: stripAutopilotMarker
   });
-  const startTool = createStartTool({
+  const stopSession = (sessionID, reason) => {
+    const state = getState(sessionID);
+    if (!state)
+      return;
+    state.mode = "DISABLED";
+    state.phase = "STOPPED";
+    state.stop_reason = "USER_STOP";
+    recordHistory(sessionID, reason ? `Cancelled by user: ${reason}` : "Cancelled by user");
+  };
+  const autopilotTool = createAutopilotTool({
     getState,
     setState,
     createSessionState,
     normalizeMaxContinues,
     initSession,
+    summarizeState: summarizeAutopilotState,
+    getHistory: (sessionID) => historyBySession.get(sessionID) ?? [],
+    onStop: stopSession,
     defaultWorkerAgent: AUTOPILOT_FALLBACK_AGENT2,
     onArmed: async (sessionID, state) => {
-      const pm = state["permissionMode"];
+      const pm = state.permissionMode;
       if (pm === "allow-all" || pm === "limited") {
         permissionModeBySession.set(sessionID, pm);
       } else {
         permissionModeBySession.set(sessionID, "limited");
       }
-      recordHistory(sessionID, `Armed in ${permissionModeBySession.get(sessionID)} mode with ${state.worker_agent}.`);
-      recordHistory(sessionID, `Continuation limit: ${state.max_continues}.`);
-    }
-  });
-  const statusTool = createStatusTool({
-    getState,
-    summarizeState: summarizeAutopilotState,
-    getHistory: (sessionID) => historyBySession.get(sessionID) ?? []
-  });
-  const stopTool = createStopTool({
-    getState,
-    onStop: (sessionID, reason) => {
-      const state = getState(sessionID);
-      if (!state)
+      if (state.session_mode === "delegated-task") {
+        recordHistory(sessionID, `Delegated task armed in ${permissionModeBySession.get(sessionID)} mode with ${state.worker_agent}.`);
+        recordHistory(sessionID, `Continuation limit: ${state.max_continues}.`);
         return;
-      state.mode = "DISABLED";
-      state.phase = "STOPPED";
-      state.stop_reason = "USER_STOP";
-      recordHistory(sessionID, reason ? `Cancelled by user: ${reason}` : "Cancelled by user");
+      }
+      recordHistory(sessionID, `Session autopilot enabled in ${permissionModeBySession.get(sessionID)} mode.`);
+      recordHistory(sessionID, `Delegate agent ready: ${state.worker_agent}. Long-running tasks will use this agent.`);
     }
   });
-  const helpTool = createHelpTool();
   return {
     tool: {
-      autopilot_start: startTool,
-      autopilot_status: statusTool,
-      autopilot_stop: stopTool,
-      autopilot_help: helpTool
+      autopilot: autopilotTool
     },
     event: eventHandler,
     "permission.ask": permissionHook,
@@ -895,5 +879,5 @@ export {
   AutopilotPlugin
 };
 
-//# debugId=7838B318ED86DB9164756E2164756E21
+//# debugId=4E4C5F5E313D2F9664756E2164756E21
 //# sourceMappingURL=index.js.map