@alan-ai-hq/agent-manager-darwin-arm64 0.1.147 → 0.1.148

package/alan-agent.cjs

@@ -19060,21 +19060,21 @@ function visit(schema, fnOrHandlers) {
       case "object": {
         const oldShape = def.shape;
         const keys = Object.keys(oldShape);
-        let changed = false;
+        let changed2 = false;
         const newShape = {};
         for (const k of keys) {
           const mapped = run2(oldShape[k]);
           if (mapped !== oldShape[k])
-            changed = true;
+            changed2 = true;
           newShape[k] = mapped;
         }
         let newCatchall = def.catchall;
         if (def.catchall) {
           newCatchall = run2(def.catchall);
           if (newCatchall !== def.catchall)
-            changed = true;
+            changed2 = true;
         }
-        return changed ? clone(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
+        return changed2 ? clone(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
       }
       case "array": {
         const mapped = run2(def.element);
@@ -19082,21 +19082,21 @@ function visit(schema, fnOrHandlers) {
       }
       case "tuple": {
         const oldItems = def.items;
-        let changed = false;
+        let changed2 = false;
         const newItems = [];
         for (const item of oldItems) {
           const mapped = run2(item);
           if (mapped !== item)
-            changed = true;
+            changed2 = true;
           newItems.push(mapped);
         }
         let newRest = def.rest;
         if (def.rest) {
           newRest = run2(def.rest);
           if (newRest !== def.rest)
-            changed = true;
+            changed2 = true;
         }
-        return changed ? clone(s, { ...def, items: newItems, rest: newRest }) : s;
+        return changed2 ? clone(s, { ...def, items: newItems, rest: newRest }) : s;
       }
       case "record":
       case "map": {
@@ -19110,15 +19110,15 @@ function visit(schema, fnOrHandlers) {
       }
       case "union": {
         const oldOptions = def.options;
-        let changed = false;
+        let changed2 = false;
         const newOptions = [];
         for (const opt of oldOptions) {
           const mapped = run2(opt);
           if (mapped !== opt)
-            changed = true;
+            changed2 = true;
           newOptions.push(mapped);
         }
-        return changed ? clone(s, { ...def, options: newOptions }) : s;
+        return changed2 ? clone(s, { ...def, options: newOptions }) : s;
       }
       case "intersection": {
         const newLeft = run2(def.left);
@@ -19568,6 +19568,262 @@ var init_zod = __esm({
   }
 });
 
+// ../shared/dist/runtime-v2/workspace.js
+function isMutatingWorkspaceQuery(request2) {
+  return request2.method === "git.checkpoint" || request2.method === "git.push" || request2.method === "git.prepare_checkout";
+}
+var UNSAFE_LINE, CONTROL_CHARACTERS, machinePathSchema, gitShaSchema, gitBranchSchema, gitRemoteNameSchema, gitRemoteUrlSchema, statusFingerprintSchema, singleLineSchema, operationIdSchema, repoTargetShape, trustedRepoTargetShape, workspaceStatusRequestSchema, gitStatusRequestSchema, gitCheckpointRequestSchema, gitPushRequestSchema, gitPrepareCheckoutRequestSchema, gitVerifyHeadRequestSchema, workspaceQueryRequestSchema, WORKSPACE_QUERY_METHODS, workspaceQueryMethodSchema, workspaceStatusValueSchema, gitStatusValueSchema, gitCheckpointValueSchema, gitPushValueSchema, gitPrepareCheckoutValueSchema, gitVerifyHeadValueSchema, WORKSPACE_QUERY_ERROR_CODES, workspaceQueryErrorCodeSchema, publishedGitReceiptSchema, workspaceQueryErrorSchema, resultEnvelopeSchema;
+var init_workspace = __esm({
+  "../shared/dist/runtime-v2/workspace.js"() {
+    "use strict";
+    init_zod();
+    UNSAFE_LINE = /[\0\r\n]/;
+    CONTROL_CHARACTERS = /[\x00-\x1f\x7f]/;
+    machinePathSchema = external_exports.string().min(1).max(4096).refine((value2) => !UNSAFE_LINE.test(value2), "path contains unsafe characters");
+    gitShaSchema = external_exports.string().regex(/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/, "not a Git SHA");
+    gitBranchSchema = external_exports.string().min(1).max(255).refine((value2) => !value2.startsWith("-") && !value2.startsWith("+") && !value2.includes("..") && !value2.includes("@{") && !value2.endsWith(".lock") && !/[\s~^:?*[\\]/.test(value2) && !CONTROL_CHARACTERS.test(value2), "not a safe Git branch name");
+    gitRemoteNameSchema = external_exports.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/, "not a safe Git remote name");
+    gitRemoteUrlSchema = external_exports.string().min(1).max(2048).refine((value2) => !UNSAFE_LINE.test(value2), "remote URL contains unsafe characters");
+    statusFingerprintSchema = external_exports.string().regex(/^[0-9a-f]{64}$/, "not a status fingerprint");
+    singleLineSchema = (max) => external_exports.string().min(1).max(max).refine((value2) => !CONTROL_CHARACTERS.test(value2), "contains control characters");
+    operationIdSchema = external_exports.guid();
+    repoTargetShape = {
+      path: machinePathSchema,
+      expectedRepoRoot: machinePathSchema.optional(),
+      projectPath: machinePathSchema.optional()
+    };
+    trustedRepoTargetShape = {
+      path: machinePathSchema,
+      expectedRepoRoot: machinePathSchema,
+      projectPath: machinePathSchema
+    };
+    workspaceStatusRequestSchema = external_exports.object({
+      method: external_exports.literal("workspace.status"),
+      path: machinePathSchema
+    });
+    gitStatusRequestSchema = external_exports.object({
+      method: external_exports.literal("git.status"),
+      ...repoTargetShape,
+      remote: gitRemoteNameSchema.default("origin"),
+      expectedRemoteUrl: gitRemoteUrlSchema.optional()
+    });
+    gitCheckpointRequestSchema = external_exports.object({
+      method: external_exports.literal("git.checkpoint"),
+      operationId: operationIdSchema,
+      ...trustedRepoTargetShape,
+      switchId: singleLineSchema(200),
+      repoKey: singleLineSchema(256),
+      expectedHeadSha: gitShaSchema,
+      expectedBranch: gitBranchSchema,
+      expectedStatusFingerprint: statusFingerprintSchema,
+      expectedProposedTreeSha: gitShaSchema,
+      /** Goes to `git commit-tree` over stdin; newlines carry trailers, NUL is unrepresentable. */
+      commitMessage: external_exports.string().min(1).max(64 * 1024).refine((value2) => !value2.includes("\0") && value2.trim().length > 0, "invalid commit message"),
+      authorName: singleLineSchema(256),
+      authorEmail: singleLineSchema(320).refine((value2) => !/[<>]/.test(value2), "invalid email")
+    });
+    gitPushRequestSchema = external_exports.object({
+      method: external_exports.literal("git.push"),
+      operationId: operationIdSchema,
+      ...trustedRepoTargetShape,
+      remote: gitRemoteNameSchema.default("origin"),
+      expectedRemoteUrl: gitRemoteUrlSchema,
+      expectedHeadSha: gitShaSchema,
+      expectedBranch: gitBranchSchema
+    });
+    gitPrepareCheckoutRequestSchema = external_exports.object({
+      method: external_exports.literal("git.prepare_checkout"),
+      operationId: operationIdSchema,
+      ...trustedRepoTargetShape,
+      remote: gitRemoteNameSchema.default("origin"),
+      expectedRemoteUrl: gitRemoteUrlSchema,
+      branch: gitBranchSchema,
+      targetSha: gitShaSchema
+    });
+    gitVerifyHeadRequestSchema = external_exports.object({
+      method: external_exports.literal("git.verify_head"),
+      ...trustedRepoTargetShape,
+      expectedSha: gitShaSchema
+    });
+    workspaceQueryRequestSchema = external_exports.discriminatedUnion("method", [
+      workspaceStatusRequestSchema,
+      gitStatusRequestSchema,
+      gitCheckpointRequestSchema,
+      gitPushRequestSchema,
+      gitPrepareCheckoutRequestSchema,
+      gitVerifyHeadRequestSchema
+    ]);
+    WORKSPACE_QUERY_METHODS = [
+      "workspace.status",
+      "git.status",
+      "git.checkpoint",
+      "git.push",
+      "git.prepare_checkout",
+      "git.verify_head"
+    ];
+    workspaceQueryMethodSchema = external_exports.enum(WORKSPACE_QUERY_METHODS);
+    workspaceStatusValueSchema = external_exports.object({
+      repoRoot: machinePathSchema,
+      /** null: detached HEAD. */
+      branch: external_exports.string().nullable(),
+      /** null: unborn branch. */
+      headSha: gitShaSchema.nullable(),
+      dirty: external_exports.boolean(),
+      filesChanged: external_exports.number().int().nonnegative(),
+      ahead: external_exports.number().int().nonnegative().nullable(),
+      behind: external_exports.number().int().nonnegative().nullable(),
+      hasUpstream: external_exports.boolean()
+    });
+    gitStatusValueSchema = workspaceStatusValueSchema.extend({
+      remoteUrl: gitRemoteUrlSchema.nullable(),
+      upstream: external_exports.string().nullable(),
+      statusFingerprint: statusFingerprintSchema,
+      proposedTreeSha: gitShaSchema
+    });
+    gitCheckpointValueSchema = external_exports.object({
+      repoRoot: machinePathSchema,
+      sha: gitShaSchema,
+      replayed: external_exports.boolean()
+    });
+    gitPushValueSchema = external_exports.object({
+      repoRoot: machinePathSchema,
+      pushedSha: gitShaSchema,
+      branch: gitBranchSchema,
+      remote: gitRemoteNameSchema,
+      /** The remote already had the SHA before this push. */
+      replayed: external_exports.boolean()
+    });
+    gitPrepareCheckoutValueSchema = external_exports.object({
+      repoRoot: machinePathSchema,
+      branch: gitBranchSchema,
+      headSha: gitShaSchema,
+      replayed: external_exports.boolean()
+    });
+    gitVerifyHeadValueSchema = external_exports.object({
+      repoRoot: machinePathSchema,
+      headSha: gitShaSchema,
+      verified: external_exports.literal(true)
+    });
+    WORKSPACE_QUERY_ERROR_CODES = [
+      "path_not_approved",
+      "workspace_busy",
+      "workspace_repository_mismatch",
+      "operation_in_progress",
+      "git_not_installed",
+      "runtime_operation_failed",
+      "invalid_git_request",
+      "repository_not_found",
+      "repository_path_changed",
+      "repository_path_not_authorized",
+      "path_canonicalization_failed",
+      "git_status_unreadable",
+      "git_operation_failed",
+      "git_network_timeout",
+      "git_output_limit_exceeded",
+      "git_remote_unavailable",
+      "git_fetch_failed",
+      "git_push_failed",
+      "remote_url_credentials_rejected",
+      "remote_url_mismatch",
+      "source_changed_since_approval",
+      "source_dirty_after_checkpoint",
+      "source_head_unreadable",
+      "checkpoint_empty",
+      "checkpoint_tree_unavailable",
+      "checkpoint_commit_failed",
+      "checkpoint_lock_unavailable",
+      "checkpoint_index_sync_failed",
+      "push_verification_failed",
+      "target_checkout_dirty",
+      "target_checkout_failed",
+      "target_branch_in_use",
+      "target_branch_diverged",
+      "target_fast_forward_failed",
+      "target_verification_failed",
+      "target_sha_mismatch",
+      "target_sha_unavailable",
+      "target_head_unreadable",
+      "verify_head_mismatch"
+    ];
+    workspaceQueryErrorCodeSchema = external_exports.enum(WORKSPACE_QUERY_ERROR_CODES);
+    publishedGitReceiptSchema = external_exports.object({
+      pushedSha: gitShaSchema,
+      branch: gitBranchSchema,
+      remote: gitRemoteNameSchema,
+      replayed: external_exports.boolean()
+    });
+    workspaceQueryErrorSchema = external_exports.object({
+      code: workspaceQueryErrorCodeSchema,
+      message: external_exports.string().max(4096),
+      /** Only with source_changed_since_approval after a push: what already reached the remote. */
+      published: publishedGitReceiptSchema.optional()
+    });
+    resultEnvelopeSchema = external_exports.discriminatedUnion("ok", [
+      external_exports.object({ ok: external_exports.literal(true), value: external_exports.unknown() }),
+      external_exports.object({ ok: external_exports.literal(false), error: workspaceQueryErrorSchema })
+    ]);
+  }
+});
+
+// ../shared/dist/runtime-v2/agent-context.js
+var AGENT_CONTEXT_VERSION, agentSessionKindSchema, agentTurnTriggerSchema, agentBranchSourceSchema, agentContextRepositorySchema, agentContextBuildSchema, agentContextEnvironmentSchema, agentContextPullRequestSchema, agentContextSchema;
+var init_agent_context = __esm({
+  "../shared/dist/runtime-v2/agent-context.js"() {
+    "use strict";
+    init_zod();
+    init_workspace();
+    AGENT_CONTEXT_VERSION = 1;
+    agentSessionKindSchema = external_exports.enum(["chat", "task", "workflow", "pr_review"]);
+    agentTurnTriggerSchema = external_exports.enum(["user", "image_build"]);
+    agentBranchSourceSchema = external_exports.enum([
+      "handoff",
+      "pull_request",
+      "task",
+      "chat_selection",
+      "environment_default"
+    ]);
+    agentContextRepositorySchema = external_exports.object({
+      name: external_exports.string().min(1).max(200),
+      url: gitRemoteUrlSchema,
+      path: machinePathSchema,
+      branch: gitBranchSchema,
+      branchSource: agentBranchSourceSchema,
+      base: gitBranchSchema
+    });
+    agentContextBuildSchema = external_exports.object({
+      id: external_exports.guid(),
+      status: external_exports.enum(["queued", "running", "succeeded", "failed", "cancelled", "superseded"]),
+      trigger: external_exports.enum(["agent", "base_bumped", "preview", "manual", "push"])
+    });
+    agentContextEnvironmentSchema = external_exports.object({
+      id: external_exports.guid(),
+      name: external_exports.string().min(1).max(200),
+      installCommand: external_exports.string().max(8192).nullable(),
+      startCommand: external_exports.string().max(8192).nullable(),
+      imageBuildId: external_exports.guid().nullable(),
+      /** The newest build when it is not the one sessions boot from. */
+      pendingBuild: agentContextBuildSchema.optional(),
+      /** Saved variable names; values never leave the API. */
+      variables: external_exports.array(external_exports.string().min(1).max(200)).max(200)
+    });
+    agentContextPullRequestSchema = external_exports.object({
+      number: external_exports.number().int().positive(),
+      url: external_exports.string().url().max(2048),
+      head: gitBranchSchema,
+      base: gitBranchSchema
+    });
+    agentContextSchema = external_exports.object({
+      kind: agentSessionKindSchema,
+      trigger: agentTurnTriggerSchema,
+      organizationId: external_exports.guid(),
+      taskWorkingBranch: gitBranchSchema.optional(),
+      pullRequest: agentContextPullRequestSchema.optional(),
+      repositories: external_exports.array(agentContextRepositorySchema).max(64),
+      environment: agentContextEnvironmentSchema.optional()
+    });
+  }
+});
+
 // ../shared/dist/skills/domain.js
 var SKILLS_PROTOCOL_VERSION, SKILL_PACKAGE_LIMITS;
 var init_domain = __esm({
@@ -20114,203 +20370,6 @@ var init_run_context = __esm({
   }
 });
 
-// ../shared/dist/runtime-v2/workspace.js
-function isMutatingWorkspaceQuery(request2) {
-  return request2.method === "git.checkpoint" || request2.method === "git.push" || request2.method === "git.prepare_checkout";
-}
-var UNSAFE_LINE, CONTROL_CHARACTERS, machinePathSchema, gitShaSchema, gitBranchSchema, gitRemoteNameSchema, gitRemoteUrlSchema, statusFingerprintSchema, singleLineSchema, operationIdSchema, repoTargetShape, trustedRepoTargetShape, workspaceStatusRequestSchema, gitStatusRequestSchema, gitCheckpointRequestSchema, gitPushRequestSchema, gitPrepareCheckoutRequestSchema, gitVerifyHeadRequestSchema, workspaceQueryRequestSchema, WORKSPACE_QUERY_METHODS, workspaceQueryMethodSchema, workspaceStatusValueSchema, gitStatusValueSchema, gitCheckpointValueSchema, gitPushValueSchema, gitPrepareCheckoutValueSchema, gitVerifyHeadValueSchema, WORKSPACE_QUERY_ERROR_CODES, workspaceQueryErrorCodeSchema, publishedGitReceiptSchema, workspaceQueryErrorSchema, resultEnvelopeSchema;
-var init_workspace = __esm({
-  "../shared/dist/runtime-v2/workspace.js"() {
-    "use strict";
-    init_zod();
-    UNSAFE_LINE = /[\0\r\n]/;
-    CONTROL_CHARACTERS = /[\x00-\x1f\x7f]/;
-    machinePathSchema = external_exports.string().min(1).max(4096).refine((value2) => !UNSAFE_LINE.test(value2), "path contains unsafe characters");
-    gitShaSchema = external_exports.string().regex(/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/, "not a Git SHA");
-    gitBranchSchema = external_exports.string().min(1).max(255).refine((value2) => !value2.startsWith("-") && !value2.startsWith("+") && !value2.includes("..") && !value2.includes("@{") && !value2.endsWith(".lock") && !/[\s~^:?*[\\]/.test(value2) && !CONTROL_CHARACTERS.test(value2), "not a safe Git branch name");
-    gitRemoteNameSchema = external_exports.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/, "not a safe Git remote name");
-    gitRemoteUrlSchema = external_exports.string().min(1).max(2048).refine((value2) => !UNSAFE_LINE.test(value2), "remote URL contains unsafe characters");
-    statusFingerprintSchema = external_exports.string().regex(/^[0-9a-f]{64}$/, "not a status fingerprint");
-    singleLineSchema = (max) => external_exports.string().min(1).max(max).refine((value2) => !CONTROL_CHARACTERS.test(value2), "contains control characters");
-    operationIdSchema = external_exports.guid();
-    repoTargetShape = {
-      path: machinePathSchema,
-      expectedRepoRoot: machinePathSchema.optional(),
-      projectPath: machinePathSchema.optional()
-    };
-    trustedRepoTargetShape = {
-      path: machinePathSchema,
-      expectedRepoRoot: machinePathSchema,
-      projectPath: machinePathSchema
-    };
-    workspaceStatusRequestSchema = external_exports.object({
-      method: external_exports.literal("workspace.status"),
-      path: machinePathSchema
-    });
-    gitStatusRequestSchema = external_exports.object({
-      method: external_exports.literal("git.status"),
-      ...repoTargetShape,
-      remote: gitRemoteNameSchema.default("origin"),
-      expectedRemoteUrl: gitRemoteUrlSchema.optional()
-    });
-    gitCheckpointRequestSchema = external_exports.object({
-      method: external_exports.literal("git.checkpoint"),
-      operationId: operationIdSchema,
-      ...trustedRepoTargetShape,
-      switchId: singleLineSchema(200),
-      repoKey: singleLineSchema(256),
-      expectedHeadSha: gitShaSchema,
-      expectedBranch: gitBranchSchema,
-      expectedStatusFingerprint: statusFingerprintSchema,
-      expectedProposedTreeSha: gitShaSchema,
-      /** Goes to `git commit-tree` over stdin; newlines carry trailers, NUL is unrepresentable. */
-      commitMessage: external_exports.string().min(1).max(64 * 1024).refine((value2) => !value2.includes("\0") && value2.trim().length > 0, "invalid commit message"),
-      authorName: singleLineSchema(256),
-      authorEmail: singleLineSchema(320).refine((value2) => !/[<>]/.test(value2), "invalid email")
-    });
-    gitPushRequestSchema = external_exports.object({
-      method: external_exports.literal("git.push"),
-      operationId: operationIdSchema,
-      ...trustedRepoTargetShape,
-      remote: gitRemoteNameSchema.default("origin"),
-      expectedRemoteUrl: gitRemoteUrlSchema,
-      expectedHeadSha: gitShaSchema,
-      expectedBranch: gitBranchSchema
-    });
-    gitPrepareCheckoutRequestSchema = external_exports.object({
-      method: external_exports.literal("git.prepare_checkout"),
-      operationId: operationIdSchema,
-      ...trustedRepoTargetShape,
-      remote: gitRemoteNameSchema.default("origin"),
-      expectedRemoteUrl: gitRemoteUrlSchema,
-      branch: gitBranchSchema,
-      targetSha: gitShaSchema
-    });
-    gitVerifyHeadRequestSchema = external_exports.object({
-      method: external_exports.literal("git.verify_head"),
-      ...trustedRepoTargetShape,
-      expectedSha: gitShaSchema
-    });
-    workspaceQueryRequestSchema = external_exports.discriminatedUnion("method", [
-      workspaceStatusRequestSchema,
-      gitStatusRequestSchema,
-      gitCheckpointRequestSchema,
-      gitPushRequestSchema,
-      gitPrepareCheckoutRequestSchema,
-      gitVerifyHeadRequestSchema
-    ]);
-    WORKSPACE_QUERY_METHODS = [
-      "workspace.status",
-      "git.status",
-      "git.checkpoint",
-      "git.push",
-      "git.prepare_checkout",
-      "git.verify_head"
-    ];
-    workspaceQueryMethodSchema = external_exports.enum(WORKSPACE_QUERY_METHODS);
-    workspaceStatusValueSchema = external_exports.object({
-      repoRoot: machinePathSchema,
-      /** null: detached HEAD. */
-      branch: external_exports.string().nullable(),
-      /** null: unborn branch. */
-      headSha: gitShaSchema.nullable(),
-      dirty: external_exports.boolean(),
-      filesChanged: external_exports.number().int().nonnegative(),
-      ahead: external_exports.number().int().nonnegative().nullable(),
-      behind: external_exports.number().int().nonnegative().nullable(),
-      hasUpstream: external_exports.boolean()
-    });
-    gitStatusValueSchema = workspaceStatusValueSchema.extend({
-      remoteUrl: gitRemoteUrlSchema.nullable(),
-      upstream: external_exports.string().nullable(),
-      statusFingerprint: statusFingerprintSchema,
-      proposedTreeSha: gitShaSchema
-    });
-    gitCheckpointValueSchema = external_exports.object({
-      repoRoot: machinePathSchema,
-      sha: gitShaSchema,
-      replayed: external_exports.boolean()
-    });
-    gitPushValueSchema = external_exports.object({
-      repoRoot: machinePathSchema,
-      pushedSha: gitShaSchema,
-      branch: gitBranchSchema,
-      remote: gitRemoteNameSchema,
-      /** The remote already had the SHA before this push. */
-      replayed: external_exports.boolean()
-    });
-    gitPrepareCheckoutValueSchema = external_exports.object({
-      repoRoot: machinePathSchema,
-      branch: gitBranchSchema,
-      headSha: gitShaSchema,
-      replayed: external_exports.boolean()
-    });
-    gitVerifyHeadValueSchema = external_exports.object({
-      repoRoot: machinePathSchema,
-      headSha: gitShaSchema,
-      verified: external_exports.literal(true)
-    });
-    WORKSPACE_QUERY_ERROR_CODES = [
-      "path_not_approved",
-      "workspace_busy",
-      "workspace_repository_mismatch",
-      "operation_in_progress",
-      "git_not_installed",
-      "runtime_operation_failed",
-      "invalid_git_request",
-      "repository_not_found",
-      "repository_path_changed",
-      "repository_path_not_authorized",
-      "path_canonicalization_failed",
-      "git_status_unreadable",
-      "git_operation_failed",
-      "git_network_timeout",
-      "git_output_limit_exceeded",
-      "git_remote_unavailable",
-      "git_fetch_failed",
-      "git_push_failed",
-      "remote_url_credentials_rejected",
-      "remote_url_mismatch",
-      "source_changed_since_approval",
-      "source_dirty_after_checkpoint",
-      "source_head_unreadable",
-      "checkpoint_empty",
-      "checkpoint_tree_unavailable",
-      "checkpoint_commit_failed",
-      "checkpoint_lock_unavailable",
-      "checkpoint_index_sync_failed",
-      "push_verification_failed",
-      "target_checkout_dirty",
-      "target_checkout_failed",
-      "target_branch_in_use",
-      "target_branch_diverged",
-      "target_fast_forward_failed",
-      "target_verification_failed",
-      "target_sha_mismatch",
-      "target_sha_unavailable",
-      "target_head_unreadable",
-      "verify_head_mismatch"
-    ];
-    workspaceQueryErrorCodeSchema = external_exports.enum(WORKSPACE_QUERY_ERROR_CODES);
-    publishedGitReceiptSchema = external_exports.object({
-      pushedSha: gitShaSchema,
-      branch: gitBranchSchema,
-      remote: gitRemoteNameSchema,
-      replayed: external_exports.boolean()
-    });
-    workspaceQueryErrorSchema = external_exports.object({
-      code: workspaceQueryErrorCodeSchema,
-      message: external_exports.string().max(4096),
-      /** Only with source_changed_since_approval after a push: what already reached the remote. */
-      published: publishedGitReceiptSchema.optional()
-    });
-    resultEnvelopeSchema = external_exports.discriminatedUnion("ok", [
-      external_exports.object({ ok: external_exports.literal(true), value: external_exports.unknown() }),
-      external_exports.object({ ok: external_exports.literal(false), error: workspaceQueryErrorSchema })
-    ]);
-  }
-});
-
 // ../shared/dist/runtime-v2/desired-state.js
 var repoLocalPathSchema, requestedCheckoutSchema, runSpecSchema, desiredRunSchema, desiredStateSchema;
 var init_desired_state = __esm({
@@ -20318,6 +20377,7 @@ var init_desired_state = __esm({
     "use strict";
     init_zod();
     init_contracts();
+    init_agent_context();
     init_ids();
     init_run_context();
     init_workspace();
@@ -20352,6 +20412,7 @@ var init_desired_state = __esm({
       repoLocalPaths: external_exports.array(repoLocalPathSchema).optional(),
       /** Applied once, at the conversation's first turn on a cloud sandbox; never moves local work. */
       requestedCheckouts: external_exports.array(requestedCheckoutSchema).max(64).optional(),
+      agentContext: agentContextSchema.optional(),
       workflowId: external_exports.guid().optional(),
       workflowExecutionId: external_exports.guid().optional(),
       agentId: external_exports.string().min(1).optional(),
@@ -21421,6 +21482,7 @@ var init_skills = __esm({
 var init_runtime_v2 = __esm({
   "../shared/dist/runtime-v2/index.js"() {
     "use strict";
+    init_agent_context();
     init_capabilities();
     init_desired_state();
     init_git_capability();
@@ -22315,7 +22377,7 @@ var init_agent = __esm({
 
 // ../shared/dist/agent/transcript/preview.js
 function toPreviewText(value2, limit) {
-  const text3 = value2.replace(/```[\s\S]*?```/g, (block) => block.replace(/```\w*\n?|```/g, " ")).replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s{0,3}#{1,6}\s+/gm, "").replace(/^\s{0,3}>\s?/gm, "").replace(/^\s{0,3}(?:[-*+]|\d+\.)\s+/gm, "").replace(/^\s{0,3}(?:[-*_]\s*){3,}$/gm, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/\*([^*\n]+)\*/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/\s+/g, " ").trim();
+  const text3 = value2.replace(/```[\s\S]*?```/g, (block2) => block2.replace(/```\w*\n?|```/g, " ")).replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s{0,3}#{1,6}\s+/gm, "").replace(/^\s{0,3}>\s?/gm, "").replace(/^\s{0,3}(?:[-*+]|\d+\.)\s+/gm, "").replace(/^\s{0,3}(?:[-*_]\s*){3,}$/gm, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/\*([^*\n]+)\*/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/\s+/g, " ").trim();
   if (text3.length <= limit)
     return text3;
   const clipped = text3.slice(0, limit - 1);
@@ -22682,8 +22744,8 @@ function decode3(bytes, start, end) {
 }
 async function linuxStartTicks(pid) {
   try {
-    const stat22 = await (0, import_promises9.readFile)(`/proc/${pid}/stat`, "utf8");
-    const fields = stat22.slice(stat22.lastIndexOf(")") + 2).split(" ");
+    const stat23 = await (0, import_promises9.readFile)(`/proc/${pid}/stat`, "utf8");
+    const fields = stat23.slice(stat23.lastIndexOf(")") + 2).split(" ");
     return fields[19];
   } catch {
     return void 0;
@@ -24125,7 +24187,7 @@ function toolEdits(node2) {
   const content = node2.event.update.content;
   if (!Array.isArray(content))
     return [];
-  return content.flatMap((block, index) => isRecord7(block) && block.type === "diff" ? readDiff(block.diff, `${node2.key}:${index}`) : []);
+  return content.flatMap((block2, index) => isRecord7(block2) && block2.type === "diff" ? readDiff(block2.diff, `${node2.key}:${index}`) : []);
 }
 function shellCommand(node2) {
   const input2 = node2.event.update.rawInput;
@@ -24231,7 +24293,7 @@ function resultText(node2) {
   const { rawOutput, content } = node2.event.update;
   if (typeof rawOutput === "string" && rawOutput.trim())
     return rawOutput;
-  return (Array.isArray(content) ? content : []).map((block) => isRecord7(block) && block.type === "content" ? block.content : block).map((block) => isRecord7(block) && typeof block.text === "string" ? block.text : "").join("");
+  return (Array.isArray(content) ? content : []).map((block2) => isRecord7(block2) && block2.type === "content" ? block2.content : block2).map((block2) => isRecord7(block2) && typeof block2.text === "string" ? block2.text : "").join("");
 }
 function parseRecord(value2) {
   try {
@@ -24376,9 +24438,9 @@ function attachChildren(nodes) {
     const u = node2.event.update;
     if (typeof u.toolCallId === "string")
       tools.set(u.toolCallId, node2);
-    for (const block of Array.isArray(u.content) ? u.content : []) {
-      if (isRecord7(block) && block.type === "terminal" && typeof block.terminalId === "string")
-        terminals.set(block.terminalId, node2);
+    for (const block2 of Array.isArray(u.content) ? u.content : []) {
+      if (isRecord7(block2) && block2.type === "terminal" && typeof block2.terminalId === "string")
+        terminals.set(block2.terminalId, node2);
     }
   }
   const parents = /* @__PURE__ */ new Map();
@@ -24416,11 +24478,11 @@ function turnStart(turn) {
 }
 function hasAnswerContent(node2) {
   const content = node2.event.update.content;
-  return Array.isArray(content) && content.some((block) => isRecord7(block) && (block.type !== "text" || typeof block.text === "string" && block.text.trim().length > 0));
+  return Array.isArray(content) && content.some((block2) => isRecord7(block2) && (block2.type !== "text" || typeof block2.text === "string" && block2.text.trim().length > 0));
 }
 function messageText(node2) {
   const content = node2.event.update.content;
-  return Array.isArray(content) ? content.flatMap((block) => isRecord7(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("") : "";
+  return Array.isArray(content) ? content.flatMap((block2) => isRecord7(block2) && block2.type === "text" && typeof block2.text === "string" ? [block2.text] : []).join("") : "";
 }
 function prepareConversationTurns(transcript, streaming, previousTurns = []) {
   const entries = Array.isArray(transcript.entries) ? transcript.entries : [];
@@ -24779,9 +24841,9 @@ function applyContent(state, index, update) {
   }
   entry.lastUpdateIndex = state.updateCount;
   if (update.sessionUpdate.endsWith("_chunk")) {
-    const block = update.content;
-    if (block)
-      entry.content.push(block);
+    const block2 = update.content;
+    if (block2)
+      entry.content.push(block2);
   } else {
     const content = update.content;
     if (content !== void 0) {
@@ -24827,9 +24889,9 @@ function applyTool(state, index, update) {
   }
   entry.lastUpdateIndex = state.updateCount;
   if (update.sessionUpdate === "tool_call_content_chunk") {
-    const block = update.content;
-    if (block)
-      entry.content.push(block);
+    const block2 = update.content;
+    if (block2)
+      entry.content.push(block2);
     return;
   }
   const u = update;
@@ -24889,8 +24951,8 @@ function toolContentText(content) {
   if (!Array.isArray(content))
     return null;
   const parts4 = [];
-  for (const block of content) {
-    const inner = isRecord8(block) && block.type === "content" ? block.content : block;
+  for (const block2 of content) {
+    const inner = isRecord8(block2) && block2.type === "content" ? block2.content : block2;
     if (!isRecord8(inner) || typeof inner.text !== "string")
       return null;
     parts4.push(inner.text);
@@ -24942,13 +25004,13 @@ function rendersBesideSteps(update) {
   const meta3 = isRecord8(update._meta) ? update._meta : {};
   return parsedFromRawOutput(update) || meta3["alan.dev/subagentLauncher"] !== void 0 || meta3["alan.dev/backgroundTask"] !== void 0;
 }
-function diffWithoutText(block) {
-  const inner = isRecord8(block) && block.type === "content" ? block.content : block;
+function diffWithoutText(block2) {
+  const inner = isRecord8(block2) && block2.type === "content" ? block2.content : block2;
   if (!isRecord8(inner) || inner.type !== "diff")
     return null;
   const path4 = typeof inner.path === "string" ? { path: inner.path } : {};
   const stub = { type: "diff", ...path4 };
-  return isRecord8(block) && block.type === "content" ? { ...block, content: stub } : stub;
+  return isRecord8(block2) && block2.type === "content" ? { ...block2, content: stub } : stub;
 }
 function stepSummary(node2) {
   const update = node2.event.update;
@@ -24960,7 +25022,7 @@ function stepSummary(node2) {
   if (update.sessionUpdate !== "tool_call_update" || rendersBesideSteps(update))
     return { ...node2, children };
   const { content, rawOutput: _rawOutput, ...rest } = update;
-  const diffs = (Array.isArray(content) ? content : []).map(diffWithoutText).filter((block) => block !== null);
+  const diffs = (Array.isArray(content) ? content : []).map(diffWithoutText).filter((block2) => block2 !== null);
   return {
     ...node2,
     event: { ...node2.event, update: diffs.length > 0 ? { ...rest, content: diffs } : rest },
@@ -25223,7 +25285,7 @@ function isRecord9(value2) {
 function scopedContent(value2, turnId) {
   if (!Array.isArray(value2))
     return value2;
-  return value2.map((block) => isRecord9(block) && block.type === "terminal" && typeof block.terminalId === "string" ? { ...block, terminalId: `${turnId}:${block.terminalId}` } : block);
+  return value2.map((block2) => isRecord9(block2) && block2.type === "terminal" && typeof block2.terminalId === "string" ? { ...block2, terminalId: `${turnId}:${block2.terminalId}` } : block2);
 }
 function scopeTranscriptEvent(value2) {
   if (!isRecord9(value2) || !Number.isSafeInteger(value2.seq) || !Number.isFinite(value2.at))
@@ -26552,8 +26614,8 @@ function readMediaFiles(candidates2, cwd, mimeByExt, maxBytes) {
     seen.add(path4);
     const mimeType = mimeByExt[(0, import_path3.extname)(path4).toLowerCase()];
     if (!mimeType) continue;
-    const stat22 = (0, import_fs4.statSync)(path4);
-    if (!stat22.isFile() || stat22.size <= 0 || stat22.size > maxBytes) continue;
+    const stat23 = (0, import_fs4.statSync)(path4);
+    if (!stat23.isFile() || stat23.size <= 0 || stat23.size > maxBytes) continue;
     files.push({ path: path4, mimeType, buffer: (0, import_fs4.readFileSync)(path4) });
   }
   return files;
@@ -27298,7 +27360,259 @@ var init_chunk_J2KTV5FP = __esm({
   }
 });
 
-// ../agent-core/dist/chunk-FPGAN4XO.js
+// ../agent-core/dist/chunk-GI3ZGXTY.js
+function repositories(input2, context) {
+  const problems = new Map(input2.problems.map((problem) => [problem.path, problem]));
+  const listed = context?.repositories ?? [];
+  const known = new Set(listed.map((repository) => repository.path));
+  const unlisted = input2.problems.filter((problem) => !known.has(problem.path));
+  return [
+    ...listed.map((repository) => {
+      const problem = problems.get(repository.path);
+      return {
+        path: repository.path,
+        name: repository.name,
+        url: repository.url,
+        branch: repository.branch,
+        branchSource: repository.branchSource,
+        base: repository.base,
+        checkout: problem ? "needs_attention" : "ok",
+        ...problem ? { problem: problem.problem, action: problem.action } : {}
+      };
+    }),
+    ...unlisted.map(
+      (problem) => ({
+        path: problem.path,
+        checkout: "needs_attention",
+        problem: problem.problem,
+        action: problem.action
+      })
+    )
+  ];
+}
+function branchInstruction(repository) {
+  const { path: path4, branch, branchSource } = repository;
+  if (!branch || !branchSource) return void 0;
+  const reason = BRANCH_REASONS[branchSource];
+  if (branchSource === "task") {
+    return `Commit work in ${path4} on ${branch}, ${reason}; create it from ${repository.base ?? "the default branch"} if it does not exist.`;
+  }
+  return `Work in ${path4} on ${branch}, ${reason}.`;
+}
+function repositoryInstructions(repository) {
+  const problem = repository.problem && repository.action ? `${repository.path} ${repository.problem}. ${repository.action} before relying on its files.` : void 0;
+  const branch = problem && repository.branchSource !== "environment_default" ? void 0 : branchInstruction(repository);
+  return [branch, problem].filter((line) => line !== void 0);
+}
+function environmentInstructions(environment, cwd) {
+  const lines2 = [];
+  const start = environment.start;
+  if (start?.state === "failed") {
+    lines2.push(
+      `The start command exited with code ${start.exitCode}. Read ${start.log}, fix the cause, then run the start command from ${cwd} before testing the app.`
+    );
+  } else if (start?.state === "pending") {
+    lines2.push(`The start command is still starting; check ${start.log} before testing the app.`);
+  }
+  const build = environment.pendingBuild;
+  if (build?.status === "queued" || build?.status === "running") {
+    lines2.push(
+      `Image build ${build.id} is ${build.status}; its result arrives as a message, so do not poll for it.`
+    );
+  } else if (build?.status === "failed") {
+    lines2.push(
+      `The latest image build (${build.id}) failed; sessions still boot from the previous image.`
+    );
+  }
+  if (environment.variables.length > 0) {
+    lines2.push("Saved variables are set in this sandbox; never print or commit their values.");
+  }
+  return lines2;
+}
+function instructionsFor(snapshot2) {
+  const cwd = snapshot2.workspace.cwd ?? snapshot2.workspace.root ?? "the workspace";
+  return [
+    ...snapshot2.session.trigger === "image_build" ? ["Alan sent this turn, not the user: it reports an image build result."] : [],
+    ...snapshot2.environment ? environmentInstructions(snapshot2.environment, cwd) : []
+  ];
+}
+function startingInstructions(snapshot2) {
+  const cwd = snapshot2.workspace.cwd ?? snapshot2.workspace.root;
+  return [
+    ...cwd ? [`Work from ${cwd}.`] : [],
+    ...snapshot2.workspace.repositories.flatMap(repositoryInstructions)
+  ];
+}
+function sessionKind(input2, context) {
+  if (context) return context.kind;
+  if (input2.spec.workflowExecutionId) return "workflow";
+  return input2.spec.taskId ? "task" : "chat";
+}
+function environmentOf(input2, context) {
+  const environment = context?.environment;
+  if (!environment) return void 0;
+  const start = environment.startCommand === null ? { state: "not_configured" } : input2.start;
+  return {
+    id: environment.id,
+    name: environment.name,
+    installCommand: environment.installCommand,
+    startCommand: environment.startCommand,
+    imageBuildId: environment.imageBuildId,
+    ...environment.pendingBuild ? { pendingBuild: environment.pendingBuild } : {},
+    variables: environment.variables,
+    ...start ? { start: start.state === "not_configured" ? start : { ...start, log: input2.startLogPath } } : {}
+  };
+}
+function knownContext(snapshot2) {
+  const organizationId = snapshot2?.session.organizationId;
+  if (!snapshot2 || !organizationId) return void 0;
+  const environment = snapshot2.environment;
+  return {
+    kind: snapshot2.session.kind,
+    trigger: "user",
+    organizationId,
+    ...snapshot2.task ? { taskWorkingBranch: snapshot2.task.workingBranch } : {},
+    ...snapshot2.pullRequest ? { pullRequest: snapshot2.pullRequest } : {},
+    repositories: snapshot2.workspace.repositories.flatMap(
+      ({ path: path4, name, url: url3, branch, branchSource, base }) => name && url3 && branch && branchSource && base ? [{ path: path4, name, url: url3, branch, branchSource, base }] : []
+    ),
+    ...environment ? {
+      environment: {
+        id: environment.id,
+        name: environment.name,
+        installCommand: environment.installCommand,
+        startCommand: environment.startCommand,
+        imageBuildId: environment.imageBuildId,
+        ...environment.pendingBuild ? { pendingBuild: environment.pendingBuild } : {},
+        variables: environment.variables
+      }
+    } : {}
+  };
+}
+function agentContextSnapshot(input2) {
+  const context = input2.spec.agentContext ?? knownContext(input2.known);
+  if (!context && input2.problems.length === 0) return null;
+  const environment = environmentOf(input2, context);
+  const base = {
+    session: {
+      kind: sessionKind(input2, context),
+      trigger: context?.trigger ?? "user",
+      conversationId: input2.spec.conversationId,
+      runId: input2.spec.runId,
+      ...input2.spec.teamId ? { teamId: input2.spec.teamId } : {},
+      ...input2.spec.taskId ? { taskId: input2.spec.taskId } : {},
+      ...input2.spec.workflowExecutionId ? { workflowExecutionId: input2.spec.workflowExecutionId } : {},
+      ...context ? { organizationId: context.organizationId } : {}
+    },
+    ...context?.taskWorkingBranch ? { task: { workingBranch: context.taskWorkingBranch } } : {},
+    ...context?.pullRequest ? { pullRequest: context.pullRequest } : {},
+    workspace: {
+      ...input2.workspaceRoot ? { root: input2.workspaceRoot } : {},
+      ...input2.spec.projectPath ? { cwd: input2.spec.projectPath } : {},
+      repositories: repositories(input2, context)
+    },
+    ...environment ? { environment } : {}
+  };
+  return { ...base, instructions: instructionsFor(base) };
+}
+function isScalar(value2) {
+  return value2 === null || typeof value2 === "string" || typeof value2 === "number" || typeof value2 === "boolean";
+}
+function scalar(value2) {
+  if (typeof value2 !== "string") return String(value2);
+  return PLAIN_SCALAR.test(value2) ? value2 : JSON.stringify(value2);
+}
+function snakeCase(key) {
+  return key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function yamlLines(record2, indent) {
+  return Object.entries(record2).flatMap(([key, value2]) => {
+    const name = `${indent}${snakeCase(key)}:`;
+    if (isScalar(value2)) return [`${name} ${scalar(value2)}`];
+    if (Array.isArray(value2)) {
+      if (value2.length === 0) return [];
+      return [
+        name,
+        ...value2.flatMap((item) => {
+          if (isScalar(item)) return [`${indent}  - ${scalar(item)}`];
+          if (typeof item !== "object" || item === null) return [];
+          const [first = "", ...rest] = yamlLines(item, `${indent}    `);
+          return [`${indent}  - ${first.trimStart()}`, ...rest];
+        })
+      ];
+    }
+    if (typeof value2 === "object" && value2 !== null)
+      return [name, ...yamlLines(value2, `${indent}  `)];
+    return [];
+  });
+}
+function block(tag, body) {
+  return [`<${tag} version="${AGENT_CONTEXT_VERSION}">`, ...yamlLines(body, ""), `</${tag}>`].join(
+    "\n"
+  );
+}
+function stableRepository(repository) {
+  const { checkout: _checkout, problem: _problem, action: _action, ...rest } = repository;
+  return rest;
+}
+function commandPreview(command) {
+  if (command === null || command.length <= COMMAND_PREVIEW_CHARS) return command;
+  const lines2 = command.split("\n").length;
+  return `${command.slice(0, COMMAND_PREVIEW_CHARS)}\u2026 (${lines2} lines; get_cloud_machine has the full command)`;
+}
+function withCommandPreviews(environment) {
+  return {
+    ...environment,
+    ...environment.installCommand !== void 0 ? { installCommand: commandPreview(environment.installCommand) } : {},
+    ...environment.startCommand !== void 0 ? { startCommand: commandPreview(environment.startCommand) } : {}
+  };
+}
+function changed(a, b) {
+  return JSON.stringify(a) !== JSON.stringify(b);
+}
+function environmentUpdate(previous, next) {
+  if (!next) return void 0;
+  const { start: previousStart, ...previousFacts } = previous ?? {};
+  const { start, ...facts } = next;
+  if (changed(previousFacts, facts)) return next;
+  return start?.state === "failed" && changed(previousStart, start) ? { start } : void 0;
+}
+function updateBody(previous, next) {
+  const known = new Set(previous.instructions);
+  const instructions = next.instructions.filter((line) => !known.has(line));
+  const before = new Map(
+    previous.workspace.repositories.map((repository) => [
+      repository.path,
+      stableRepository(repository)
+    ])
+  );
+  const repositories2 = next.workspace.repositories.map(stableRepository).filter(
+    (repository) => repository.path !== void 0 && changed(before.get(repository.path), repository)
+  );
+  const environment = environmentUpdate(previous.environment, next.environment);
+  const facts = {
+    ...changed(previous.task, next.task) && next.task ? { task: next.task } : {},
+    ...changed(previous.pullRequest, next.pullRequest) && next.pullRequest ? { pullRequest: next.pullRequest } : {},
+    ...repositories2.length > 0 ? { workspace: { repositories: repositories2 } } : {},
+    ...environment ? { environment: withCommandPreviews(environment) } : {},
+    ...instructions.length > 0 ? { instructions } : {}
+  };
+  if (Object.keys(facts).length === 0) return void 0;
+  return next.session.trigger === "user" ? facts : { session: { trigger: next.session.trigger }, ...facts };
+}
+function renderAgentContext(snapshot2, previous) {
+  const full = block("alan_agent_context", {
+    ...snapshot2,
+    ...snapshot2.environment ? { environment: withCommandPreviews(snapshot2.environment) } : {},
+    instructions: [...startingInstructions(snapshot2), ...snapshot2.instructions]
+  });
+  const update = previous ? updateBody(previous, snapshot2) : void 0;
+  return {
+    snapshot: snapshot2,
+    full,
+    ...update ? { update: block("alan_agent_context_update", update) } : {}
+  };
+}
 function truncate(value2, limit) {
   const normalized2 = Array.from(value2, (character) => {
     const code = character.charCodeAt(0);
@@ -27557,11 +27871,12 @@ function cloudExecutionSection(spec) {
   if (spec.sandboxId) lines2.push(`Sandbox ID: ${spec.sandboxId}.`);
   if (spec.cloudEnvironmentId) lines2.push(`Cloud environment ID: ${spec.cloudEnvironmentId}.`);
   lines2.push(
-    "Run setup, development and validation in this sandbox. The execution location is separate from the deployment of the application you are testing; verify that application's origin before acting."
+    "Run setup, development and validation in this sandbox. The execution location is separate from the deployment of the application you are testing; verify that application's origin before acting.",
+    "A turn can begin with an <alan_agent_context> block, or an <alan_agent_context_update> with only what changed since. Alan writes these, not the user: they state this session's repositories, branches, environment and start command state, and their instructions apply."
   );
   if (!isReadOnlyMode(spec.mode) && !isReadOnlyAgent(spec.agentId)) {
     lines2.push(
-      "Own the authorized work end to end: inspect context, make reasonable assumptions, implement, test, review and create or update the pull request for code changes when the repository workflow calls for one. Do not stop at a plan or ask for routine implementation choices or permission already granted. For application changes, check the repository's setup instructions and configured start commands, start the app if needed, and verify it is reachable before testing. For user-facing flows, use alan-test-feature when installed to test the running app, capture a video, and create a test report. Ask only for a missing secret, an essential decision you cannot derive, or an action requiring explicit approval. Respect the user's scope, repository rules and tool authorization; report blocked capabilities and validation gaps while continuing independent work."
+      "Own the authorized work end to end: inspect context, make reasonable assumptions, implement, test, review and create or update the pull request for code changes when the repository workflow calls for one. Do not stop at a plan or ask for routine implementation choices or permission already granted. For application changes, follow the session context for where to work and whether the start command is running, start the app if needed, and verify it is reachable before testing. For user-facing flows, use alan-test-feature when installed to test the running app, capture a video, and create a test report. Ask only for a missing secret, an essential decision you cannot derive, or an action requiring explicit approval. Respect the user's scope, repository rules and tool authorization; report blocked capabilities and validation gaps while continuing independent work."
     );
   }
   const skills = spec.promptContext?.availableSkills ?? [];
@@ -27658,11 +27973,71 @@ function buildTurnText(input2) {
 ${body}` : body;
   return spec.mode === "plan" ? planModePrefix(prefixed) : prefixed;
 }
-var MAX_PARSED_ATTACHMENTS, MAX_PARSED_ATTACHMENT_CHARS, MAX_METADATA_CHARS, UNAVAILABLE, READ_ONLY_MODES, AGENT_MODES;
-var init_chunk_FPGAN4XO = __esm({
-  "../agent-core/dist/chunk-FPGAN4XO.js"() {
+var startCommandStateSchema, repositorySnapshotSchema, environmentSnapshotSchema, agentContextSnapshotSchema, BRANCH_REASONS, PLAIN_SCALAR, COMMAND_PREVIEW_CHARS, MAX_PARSED_ATTACHMENTS, MAX_PARSED_ATTACHMENT_CHARS, MAX_METADATA_CHARS, UNAVAILABLE, READ_ONLY_MODES, AGENT_MODES;
+var init_chunk_GI3ZGXTY = __esm({
+  "../agent-core/dist/chunk-GI3ZGXTY.js"() {
     "use strict";
+    init_runtime_v2();
+    init_zod();
     init_agent2();
+    startCommandStateSchema = external_exports.discriminatedUnion("state", [
+      external_exports.object({ state: external_exports.literal("not_configured") }),
+      external_exports.object({ state: external_exports.literal("pending") }),
+      external_exports.object({ state: external_exports.literal("running") }),
+      external_exports.object({ state: external_exports.literal("exited_ok") }),
+      external_exports.object({ state: external_exports.literal("failed"), exitCode: external_exports.number().int() })
+    ]);
+    repositorySnapshotSchema = external_exports.object({
+      path: external_exports.string(),
+      name: external_exports.string().optional(),
+      url: external_exports.string().optional(),
+      branch: external_exports.string().optional(),
+      branchSource: agentBranchSourceSchema.optional(),
+      base: external_exports.string().optional(),
+      checkout: external_exports.enum(["ok", "needs_attention"]),
+      problem: external_exports.string().optional(),
+      action: external_exports.string().optional()
+    });
+    environmentSnapshotSchema = external_exports.object({
+      id: external_exports.string(),
+      name: external_exports.string(),
+      installCommand: external_exports.string().nullable(),
+      startCommand: external_exports.string().nullable(),
+      imageBuildId: external_exports.string().nullable(),
+      pendingBuild: agentContextBuildSchema.optional(),
+      variables: external_exports.array(external_exports.string()),
+      start: external_exports.intersection(startCommandStateSchema, external_exports.object({ log: external_exports.string().optional() })).optional()
+    });
+    agentContextSnapshotSchema = external_exports.object({
+      session: external_exports.object({
+        kind: agentSessionKindSchema,
+        trigger: agentTurnTriggerSchema,
+        conversationId: external_exports.string(),
+        runId: external_exports.string(),
+        teamId: external_exports.string().optional(),
+        taskId: external_exports.string().optional(),
+        workflowExecutionId: external_exports.string().optional(),
+        organizationId: external_exports.string().optional()
+      }),
+      task: external_exports.object({ workingBranch: external_exports.string() }).optional(),
+      pullRequest: agentContextPullRequestSchema.optional(),
+      workspace: external_exports.object({
+        root: external_exports.string().optional(),
+        cwd: external_exports.string().optional(),
+        repositories: external_exports.array(repositorySnapshotSchema)
+      }),
+      environment: environmentSnapshotSchema.optional(),
+      instructions: external_exports.array(external_exports.string())
+    });
+    BRANCH_REASONS = {
+      handoff: "the branch handed off from the user's computer",
+      pull_request: "this pull request's branch",
+      task: "this task's branch",
+      chat_selection: "the branch the user selected for this chat",
+      environment_default: "the environment's default branch"
+    };
+    PLAIN_SCALAR = /^[A-Za-z0-9_./@~+-][A-Za-z0-9_./@~+:-]*$/;
+    COMMAND_PREVIEW_CHARS = 200;
     MAX_PARSED_ATTACHMENTS = 3;
     MAX_PARSED_ATTACHMENT_CHARS = 12e3;
     MAX_METADATA_CHARS = 240;
@@ -28100,16 +28475,16 @@ function parseClaudeEvent(event, state) {
 }
 function thoughtsOf(event, content, messageId, state) {
   const texts = content.flatMap((raw) => {
-    const block = asRecord(raw);
-    if (!block || asString(block.type) !== "thinking") return [];
-    return [asString(block.thinking) || asString(block.text)];
+    const block2 = asRecord(raw);
+    if (!block2 || asString(block2.type) !== "thinking") return [];
+    return [asString(block2.thinking) || asString(block2.text)];
   });
   if (texts.length === 0) return [];
   const frameId = asString(event.uuid) || synthId(state, "claude-thought-frame");
   return thoughtBlocksFor(state, messageId).complete(frameId, texts);
 }
-function textUpdates(frame, block) {
-  const text22 = asString(block.text);
+function textUpdates(frame, block2) {
+  const text22 = asString(block2.text);
   if (!text22 || frame.alreadyStreamed) return [];
   const content = textBlock(frame.previousBlockWasText ? `
 ${text22}` : text22);
@@ -28130,12 +28505,12 @@ function thoughtUpdates(frame) {
     }
   ];
 }
-function blockUpdates(frame, block) {
-  const blockType = asString(block.type);
-  if (blockType === "text") return textUpdates(frame, block);
+function blockUpdates(frame, block2) {
+  const blockType = asString(block2.type);
+  if (blockType === "text") return textUpdates(frame, block2);
   frame.previousBlockWasText = false;
   if (blockType === "thinking") return thoughtUpdates(frame);
-  if (blockType === "tool_use") return parseToolUse(block, frame.meta);
+  if (blockType === "tool_use") return parseToolUse(block2, frame.meta);
   return [];
 }
 function parseAssistant(event, state) {
@@ -28153,8 +28528,8 @@ function parseAssistant(event, state) {
     previousBlockWasText: false
   };
   return content.flatMap((raw) => {
-    const block = asRecord(raw);
-    return block ? blockUpdates(frame, block) : [];
+    const block2 = asRecord(raw);
+    return block2 ? blockUpdates(frame, block2) : [];
   });
 }
 function toolUseMeta(name, input2, meta3) {
@@ -28167,11 +28542,11 @@ function toolUseMeta(name, input2, meta3) {
     ...!isAsk && normalizeToolName2(name) === "exitplanmode" ? { [EXIT_PLAN_MODE_INPUT_META]: input2 } : {}
   };
 }
-function parseToolUse(block, meta3) {
-  const toolCallId = asString(block.id);
+function parseToolUse(block2, meta3) {
+  const toolCallId = asString(block2.id);
   if (!toolCallId) return [];
-  const name = canonicalizeManagedMcpToolName(asString(block.name));
-  const input2 = block.input;
+  const name = canonicalizeManagedMcpToolName(asString(block2.name));
+  const input2 = block2.input;
   const inputRecord = asRecord(input2) ?? {};
   const pendingFileChange = claudeToolInputDiffContent(name, input2);
   const updates = [
@@ -28213,21 +28588,21 @@ function parseUser(event) {
   if (!message2) return [];
   const meta3 = nesting(event);
   return asArray(message2.content).flatMap((raw) => {
-    const block = asRecord(raw);
-    if (!block || asString(block.type) !== "tool_result") return [];
-    const toolCallId = asString(block.tool_use_id);
+    const block2 = asRecord(raw);
+    if (!block2 || asString(block2.type) !== "tool_result") return [];
+    const toolCallId = asString(block2.tool_use_id);
     if (!toolCallId) return [];
-    const text22 = flattenToolResult(block.content);
+    const text22 = flattenToolResult(block2.content);
     const content = outputContent(text22);
     const diffs = claudeFileChangeContents(event.tool_use_result);
     return [
       {
         sessionUpdate: "tool_call_update",
         toolCallId,
-        status: block.is_error === true ? "failed" : "completed",
+        status: block2.is_error === true ? "failed" : "completed",
         ...content || diffs.length ? { content: [...diffs, ...content ?? []] } : {},
         rawOutput: text22,
-        _meta: { ...meta3._meta, [PROVIDER_PAYLOAD_META]: event.tool_use_result ?? block }
+        _meta: { ...meta3._meta, [PROVIDER_PAYLOAD_META]: event.tool_use_result ?? block2 }
       }
     ];
   });
@@ -28740,12 +29115,12 @@ function isTopLevel(record2) {
   return record2.isSidechain !== true;
 }
 function hasToolResult(content) {
-  return asArray(content).some((block) => asString(asRecord(block)?.type) === "tool_result");
+  return asArray(content).some((block2) => asString(asRecord(block2)?.type) === "tool_result");
 }
 function userText(content) {
   if (typeof content === "string") return content;
-  return asArray(content).map((block) => {
-    const record2 = asRecord(block);
+  return asArray(content).map((block2) => {
+    const record2 = asRecord(block2);
     return record2 && asString(record2.type) === "text" ? asString(record2.text) : "";
   }).filter(Boolean).join("\n");
 }
@@ -28781,8 +29156,8 @@ function claudeTranscriptModel(record2) {
 function claudeTranscriptTurnError(record2) {
   if (asString(record2.type) !== "assistant" || !isTopLevel(record2)) return null;
   if (record2.isApiErrorMessage !== true) return null;
-  const text22 = asArray(asRecord(record2.message)?.content).map((block) => {
-    const part = asRecord(block);
+  const text22 = asArray(asRecord(record2.message)?.content).map((block2) => {
+    const part = asRecord(block2);
     return part && asString(part.type) === "text" ? asString(part.text) : "";
   }).join("").trim();
   return text22 || asString(record2.error) || "The provider request failed";
@@ -28940,7 +29315,7 @@ var init_claude = __esm({
     init_chunk_HBIPWAUI();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
-    init_chunk_FPGAN4XO();
+    init_chunk_GI3ZGXTY();
     init_chunk_YXWJW7I5();
     init_effort();
     import_crypto6 = require("crypto");
@@ -29463,11 +29838,11 @@ var init_claude = __esm({
         }
         this.#iterations += 1;
         for (const raw of asArray(asRecord(event.message)?.content)) {
-          const block = asRecord(raw);
-          if (!block || asString(block.type) !== "tool_use") continue;
-          const id = asString(block.id);
+          const block2 = asRecord(raw);
+          if (!block2 || asString(block2.type) !== "tool_use") continue;
+          const id = asString(block2.id);
           if (!id) continue;
-          const name = canonicalizeManagedMcpToolName(asString(block.name));
+          const name = canonicalizeManagedMcpToolName(asString(block2.name));
           if (isInteractiveToolName(name) || INTERACTIVE_TOOL_NAMES.has(normalizeToolName2(name))) {
             this.#suppressedResults.add(id);
           }
@@ -31114,9 +31489,9 @@ function contentText(content, separator = "") {
   if (typeof content === "string") return content;
   const parts22 = [];
   for (const raw of asArray(content)) {
-    const block = asRecord(raw);
-    if (!block) continue;
-    const text3 = asString(block.text) || asString(block.input_text) || asString(block.output_text);
+    const block2 = asRecord(raw);
+    if (!block2) continue;
+    const text3 = asString(block2.text) || asString(block2.input_text) || asString(block2.output_text);
     if (text3) parts22.push(text3);
   }
   return parts22.join(separator);
@@ -31129,9 +31504,9 @@ function codexRolloutPromptText(payload) {
   const kinds = asArray(passthroughOf(payload)?.content_item_kinds);
   const parts22 = [];
   asArray(payload.content).forEach((raw, index) => {
-    const block = asRecord(raw);
-    if (!block) return;
-    const text3 = asString(block.text) || asString(block.input_text);
+    const block2 = asRecord(raw);
+    if (!block2) return;
+    const text3 = asString(block2.text) || asString(block2.input_text);
     if (!text3) return;
     const kind = asString(kinds[index]);
     const typed = kind ? kind.startsWith("user.") : !INJECTED_USER_PREFIXES.some((prefix) => text3.trimStart().startsWith(prefix));
@@ -31799,7 +32174,7 @@ var init_codex = __esm({
     init_chunk_HBIPWAUI();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
-    init_chunk_FPGAN4XO();
+    init_chunk_GI3ZGXTY();
     init_chunk_YXWJW7I5();
     import_fs6 = require("fs");
     import_path6 = require("path");
@@ -33379,7 +33754,7 @@ var require_identity = __commonJS({
     var isDocument = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === DOC;
     var isMap = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === MAP;
     var isPair = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === PAIR;
-    var isScalar = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === SCALAR;
+    var isScalar2 = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === SCALAR;
     var isSeq = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === SEQ;
     function isCollection(node2) {
       if (node2 && typeof node2 === "object")
@@ -33401,7 +33776,7 @@ var require_identity = __commonJS({
         }
       return false;
     }
-    var hasAnchor = (node2) => (isScalar(node2) || isCollection(node2)) && !!node2.anchor;
+    var hasAnchor = (node2) => (isScalar2(node2) || isCollection(node2)) && !!node2.anchor;
     exports2.ALIAS = ALIAS;
     exports2.DOC = DOC;
     exports2.MAP = MAP;
@@ -33416,7 +33791,7 @@ var require_identity = __commonJS({
     exports2.isMap = isMap;
     exports2.isNode = isNode;
     exports2.isPair = isPair;
-    exports2.isScalar = isScalar;
+    exports2.isScalar = isScalar2;
     exports2.isSeq = isSeq;
   }
 });
@@ -37772,13 +38147,13 @@ var require_resolve_block_scalar = __commonJS({
   "../../node_modules/yaml/dist/compose/resolve-block-scalar.js"(exports2) {
     "use strict";
     var Scalar = require_Scalar();
-    function resolveBlockScalar(ctx, scalar, onError) {
-      const start = scalar.offset;
-      const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError);
+    function resolveBlockScalar(ctx, scalar2, onError) {
+      const start = scalar2.offset;
+      const header = parseBlockScalarHeader(scalar2, ctx.options.strict, onError);
       if (!header)
         return { value: "", type: null, comment: "", range: [start, start, start] };
       const type = header.mode === ">" ? Scalar.Scalar.BLOCK_FOLDED : Scalar.Scalar.BLOCK_LITERAL;
-      const lines2 = scalar.source ? splitLines(scalar.source) : [];
+      const lines2 = scalar2.source ? splitLines(scalar2.source) : [];
       let chompStart = lines2.length;
       for (let i = lines2.length - 1; i >= 0; --i) {
         const content = lines2[i][1];
@@ -37790,12 +38165,12 @@ var require_resolve_block_scalar = __commonJS({
       if (chompStart === 0) {
         const value3 = header.chomp === "+" && lines2.length > 0 ? "\n".repeat(Math.max(1, lines2.length - 1)) : "";
         let end2 = start + header.length;
-        if (scalar.source)
-          end2 += scalar.source.length;
+        if (scalar2.source)
+          end2 += scalar2.source.length;
         return { value: value3, type, comment: header.comment, range: [start, end2, end2] };
       }
-      let trimIndent = scalar.indent + header.indent;
-      let offset = scalar.offset + header.length;
+      let trimIndent = scalar2.indent + header.indent;
+      let offset = scalar2.offset + header.length;
       let contentStart = 0;
       for (let i = 0; i < chompStart; ++i) {
         const [indent, content] = lines2[i];
@@ -37873,7 +38248,7 @@ var require_resolve_block_scalar = __commonJS({
         default:
           value2 += "\n";
       }
-      const end = start + header.length + scalar.source.length;
+      const end = start + header.length + scalar2.source.length;
       return { value: value2, type, comment: header.comment, range: [start, end, end] };
     }
     function parseBlockScalarHeader({ offset, props }, strict, onError) {
@@ -37956,8 +38331,8 @@ var require_resolve_flow_scalar = __commonJS({
     "use strict";
     var Scalar = require_Scalar();
     var resolveEnd = require_resolve_end();
-    function resolveFlowScalar(scalar, strict, onError) {
-      const { offset, type, source, end } = scalar;
+    function resolveFlowScalar(scalar2, strict, onError) {
+      const { offset, type, source, end } = scalar2;
       let _type;
       let value2;
       const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
@@ -37976,7 +38351,7 @@ var require_resolve_flow_scalar = __commonJS({
           break;
         /* istanbul ignore next should not happen */
         default:
-          onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
+          onError(scalar2, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
           return {
             value: "",
             type: null,
@@ -38190,26 +38565,26 @@ var require_compose_scalar = __commonJS({
         tag = findScalarTagByTest(ctx, value2, token, onError);
       else
         tag = ctx.schema[identity.SCALAR];
-      let scalar;
+      let scalar2;
       try {
         const res = tag.resolve(value2, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
-        scalar = identity.isScalar(res) ? res : new Scalar.Scalar(res);
+        scalar2 = identity.isScalar(res) ? res : new Scalar.Scalar(res);
       } catch (error61) {
         const msg = error61 instanceof Error ? error61.message : String(error61);
         onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
-        scalar = new Scalar.Scalar(value2);
+        scalar2 = new Scalar.Scalar(value2);
       }
-      scalar.range = range;
-      scalar.source = value2;
+      scalar2.range = range;
+      scalar2.source = value2;
       if (type)
-        scalar.type = type;
+        scalar2.type = type;
       if (tagName)
-        scalar.tag = tagName;
+        scalar2.tag = tagName;
       if (tag.format)
-        scalar.format = tag.format;
+        scalar2.format = tag.format;
       if (comment)
-        scalar.comment = comment;
-      return scalar;
+        scalar2.comment = comment;
+      return scalar2;
     }
     function findScalarTagByName(schema, value2, tagName, tagToken, onError) {
       if (tagName === "!")
@@ -38958,7 +39333,7 @@ var require_cst = __commonJS({
     var FLOW_END = "";
     var SCALAR = "";
     var isCollection = (token) => !!token && "items" in token;
-    var isScalar = (token) => !!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar");
+    var isScalar2 = (token) => !!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar");
     function prettyToken(token) {
       switch (token) {
         case BOM:
@@ -39042,7 +39417,7 @@ var require_cst = __commonJS({
     exports2.FLOW_END = FLOW_END;
     exports2.SCALAR = SCALAR;
     exports2.isCollection = isCollection;
-    exports2.isScalar = isScalar;
+    exports2.isScalar = isScalar2;
     exports2.prettyToken = prettyToken;
     exports2.tokenType = tokenType;
   }
@@ -40037,37 +40412,37 @@ var require_parser = __commonJS({
           };
         }
       }
-      *scalar(scalar) {
+      *scalar(scalar2) {
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
           let sep4;
-          if (scalar.end) {
-            sep4 = scalar.end;
+          if (scalar2.end) {
+            sep4 = scalar2.end;
             sep4.push(this.sourceToken);
-            delete scalar.end;
+            delete scalar2.end;
           } else
             sep4 = [this.sourceToken];
           const map2 = {
             type: "block-map",
-            offset: scalar.offset,
-            indent: scalar.indent,
-            items: [{ start, key: scalar, sep: sep4 }]
+            offset: scalar2.offset,
+            indent: scalar2.indent,
+            items: [{ start, key: scalar2, sep: sep4 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map2;
         } else
-          yield* this.lineEnd(scalar);
+          yield* this.lineEnd(scalar2);
       }
-      *blockScalar(scalar) {
+      *blockScalar(scalar2) {
         switch (this.type) {
           case "space":
           case "comment":
           case "newline":
-            scalar.props.push(this.sourceToken);
+            scalar2.props.push(this.sourceToken);
             return;
           case "scalar":
-            scalar.source = this.source;
+            scalar2.source = this.source;
             this.atNewLine = true;
             this.indent = 0;
             if (this.onNewLine) {
@@ -42442,16 +42817,16 @@ var require_headers = __commonJS({
       }
       return 0;
     }
-    function indexOf(block, num2, offset, end) {
+    function indexOf(block2, num2, offset, end) {
       for (; offset < end; offset++) {
-        if (block[offset] === num2) return offset;
+        if (block2[offset] === num2) return offset;
       }
       return end;
     }
-    function cksum(block) {
+    function cksum(block2) {
       let sum = 8 * 32;
-      for (let i = 0; i < 148; i++) sum += block[i];
-      for (let j = 156; j < 512; j++) sum += block[j];
+      for (let i = 0; i < 148; i++) sum += block2[i];
+      for (let j = 156; j < 512; j++) sum += block2[j];
       return sum;
     }
     function encodeOct(val, n) {
@@ -43226,7 +43601,7 @@ function within(root, path4) {
 }
 async function resolveReal(path4) {
   try {
-    return await (0, import_promises49.realpath)(path4);
+    return await (0, import_promises50.realpath)(path4);
   } catch {
     const parent = (0, import_path9.dirname)(path4);
     if (parent === path4) return path4;
@@ -43255,14 +43630,14 @@ function createWorkspaceFs(roots, writable) {
   return {
     read: async (params) => {
       const path4 = await confined(params);
-      const bytes = await (0, import_promises49.readFile)(path4);
+      const bytes = await (0, import_promises50.readFile)(path4);
       if (bytes.byteLength > MAX_READ_BYTES) throw new FsDenied(`${path4} is too large to read`);
       return { content: sliceLines(bytes.toString("utf8"), params) };
     },
     write: async (params) => {
       if (!writable) throw new FsDenied("This session is read-only");
       const path4 = await confined(params);
-      await (0, import_promises49.writeFile)(path4, asString(params.content));
+      await (0, import_promises50.writeFile)(path4, asString(params.content));
       return {};
     }
   };
@@ -43359,8 +43734,8 @@ function refusal(error61, displayName) {
   return failure3("failed", String(error61));
 }
 function toolResultText(update) {
-  const texts = (update.content ?? []).flatMap((block) => {
-    const text3 = asString(asRecord(asRecord(block)?.content)?.text);
+  const texts = (update.content ?? []).flatMap((block2) => {
+    const text3 = asString(asRecord(asRecord(block2)?.content)?.text);
     return text3 ? [text3] : [];
   });
   if (typeof update.rawOutput === "string" && update.rawOutput) texts.push(update.rawOutput);
@@ -43456,11 +43831,11 @@ function isStopReason(value2) {
 function v2ToolContent(content) {
   if (!Array.isArray(content)) return void 0;
   return content.map((item) => {
-    const block = asRecord(item);
-    if (!block || asString(block.type) !== "diff" || asRecord(block.diff)) return item;
-    const path4 = asString(block.path);
-    const oldText = typeof block.oldText === "string" ? block.oldText : null;
-    const newText = typeof block.newText === "string" ? block.newText : null;
+    const block2 = asRecord(item);
+    if (!block2 || asString(block2.type) !== "diff" || asRecord(block2.diff)) return item;
+    const path4 = asString(block2.path);
+    const oldText = typeof block2.oldText === "string" ? block2.oldText : null;
+    const newText = typeof block2.newText === "string" ? block2.newText : null;
     const operation = oldText === null ? "add" : newText === null ? "delete" : "modify";
     return {
       type: "diff",
@@ -43865,7 +44240,7 @@ async function acpTurnInput(run2, context) {
   const encoded = await Promise.all(
     images.map(async (image) => ({
       mimeType: image.mimeType,
-      data: (await (0, import_promises50.readFile)(image.path)).toString("base64")
+      data: (await (0, import_promises51.readFile)(image.path)).toString("base64")
     }))
   );
   return {
@@ -43874,7 +44249,7 @@ async function acpTurnInput(run2, context) {
     ...encoded.length ? { images: encoded, imagePaths: images.map((image) => image.path) } : {}
   };
 }
-var import_promises49, import_path9, import_crypto13, import_promises50, CURSOR_ASK_QUESTION, copilotAcpProfile, cursorAcpProfile, MODEL_REJECTED, MAX_READ_BYTES, FsDenied, ENV_REFERENCE, AcpBackgroundTasks, CURSOR_CREATE_PLAN, STATUSES2, READ_KINDS, ALLOW_KINDS, REJECT_KINDS, CANCELLED_PERMISSION, STOP_REASONS, CHUNKS, ECHOES, AcpTurn, STDERR_TAIL_LINES4, MAX_BETWEEN_UPDATES2, AcpSession, DEFAULTS3, CLIENT_INFO2, TASK_BACKGROUNDED, TASK_COMPLETED, SESSION_NOTIFICATION, KILLED_STATUSES, SUCCESS_STATUSES, SUBAGENT_ID, grokTaskDialect, grokAcpProfile, kimiAcpProfile, ACP_PROFILES, ACP_MODES;
+var import_promises50, import_path9, import_crypto13, import_promises51, CURSOR_ASK_QUESTION, copilotAcpProfile, cursorAcpProfile, MODEL_REJECTED, MAX_READ_BYTES, FsDenied, ENV_REFERENCE, AcpBackgroundTasks, CURSOR_CREATE_PLAN, STATUSES2, READ_KINDS, ALLOW_KINDS, REJECT_KINDS, CANCELLED_PERMISSION, STOP_REASONS, CHUNKS, ECHOES, AcpTurn, STDERR_TAIL_LINES4, MAX_BETWEEN_UPDATES2, AcpSession, DEFAULTS3, CLIENT_INFO2, TASK_BACKGROUNDED, TASK_COMPLETED, SESSION_NOTIFICATION, KILLED_STATUSES, SUCCESS_STATUSES, SUBAGENT_ID, grokTaskDialect, grokAcpProfile, kimiAcpProfile, ACP_PROFILES, ACP_MODES;
 var init_acp3 = __esm({
   "../agent-core/dist/providers/acp.js"() {
     "use strict";
@@ -43883,14 +44258,14 @@ var init_acp3 = __esm({
     init_chunk_HBIPWAUI();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
-    init_chunk_FPGAN4XO();
+    init_chunk_GI3ZGXTY();
     init_chunk_YXWJW7I5();
-    import_promises49 = require("fs/promises");
+    import_promises50 = require("fs/promises");
     import_path9 = require("path");
     init_effort();
     init_acp();
     import_crypto13 = require("crypto");
-    import_promises50 = require("fs/promises");
+    import_promises51 = require("fs/promises");
     init_agent2();
     CURSOR_ASK_QUESTION = "cursor/ask_question";
     copilotAcpProfile = {
@@ -44710,6 +45085,9 @@ var init_driver = __esm({
 });
 
 // src/holder/drivers/persistent.ts
+function sessionContextFor(opened, inputs) {
+  return opened.fresh ? inputs.agentContext?.full : inputs.agentContext?.update;
+}
 function errorMessage(error61) {
   return error61 instanceof Error ? error61.message : String(error61);
 }
@@ -44765,14 +45143,14 @@ function createPersistentDriver(provider4, options) {
   const resumeNotice = (spec, session, sink) => {
     if (spec.resumeFallbackContext) {
       log.info("holder.session_resume_fallback", { harness: provider4.harness, runId: spec.runId });
-      return { session, contextPrefix: spec.resumeFallbackContext };
+      return { session, fresh: true, contextPrefix: spec.resumeFallbackContext };
     }
     sink.onEvent({
       seq: 0,
       at: clock.now(),
       update: noticeUpdate("warning", "session_resume_failed", RESUME_UNAVAILABLE)
     });
-    return { session };
+    return { session, fresh: true };
   };
   const managedMcpAccess = async (signal) => {
     const managed = options.managedMcp;
@@ -44783,7 +45161,7 @@ function createPersistentDriver(provider4, options) {
   const ensureSession = async (spec, inputs, sink, managedMcp) => {
     const wanted = provider4.plan(spec, inputs, void 0, managedMcp);
     const reused = await reuseLive(spec, wanted.key);
-    if (reused) return { session: reused };
+    if (reused) return { session: reused, fresh: false };
     const requested = live.providerSessionId ?? spec.providerSessionId;
     const resumeId = requested !== void 0 && requested !== live.rejectedSessionId && provider4.canResume(wanted, requested) ? requested : void 0;
     const planned = provider4.plan(spec, inputs, resumeId, managedMcp);
@@ -44802,7 +45180,7 @@ function createPersistentDriver(provider4, options) {
       requested
     });
     const resumed = resumeId !== void 0 && !opened.resumeFailed;
-    if (requested === void 0 || resumed) return { session: opened.session };
+    if (requested === void 0 || resumed) return { session: opened.session, fresh: !resumed };
     return resumeNotice(spec, opened.session, sink);
   };
   const runOnSession = async (opened, spec, sink, signal, inputs) => {
@@ -44854,7 +45232,7 @@ function createPersistentDriver(provider4, options) {
       };
       signal.addEventListener("abort", onAbort, { once: true });
       try {
-        const contextPrefix = [inputs.turnContext, opened.contextPrefix].filter((part) => part !== void 0).join("\n\n");
+        const contextPrefix = [sessionContextFor(opened, inputs), opened.contextPrefix].filter((part) => part !== void 0).join("\n\n");
         const input2 = await provider4.turnInput(spec, inputs, contextPrefix || void 0);
         if (signal.aborted) return { outcome: "aborted" };
         const result = await session.sendTurn(input2);
@@ -45035,8 +45413,8 @@ var init_acp4 = __esm({
 });
 
 // ../agent-core/dist/providers/opencode.js
-function parseSseBlock(block) {
-  const data = block.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
+function parseSseBlock(block2) {
+  const data = block2.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
   if (!data) return void 0;
   let parsed;
   try {
@@ -45415,7 +45793,7 @@ async function sameDirectory(left, right) {
 }
 async function canonicalDirectory(directory) {
   try {
-    return await (0, import_promises51.realpath)(directory);
+    return await (0, import_promises52.realpath)(directory);
   } catch {
     return (0, import_path10.resolve)(directory);
   }
@@ -45611,7 +45989,7 @@ function openCodeTurnInput(run2, context) {
     ...images.length ? { imagePaths: images.map((image) => image.path) } : {}
   };
 }
-var import_http10, import_crypto14, import_promises51, import_path10, import_path11, import_url2, import_crypto15, IDLE_SOCKET_MS3, OpenCodeHttpError, OpenCodeClient, OPENCODE_CONFIG_ENV, OPENCODE_ENGINE, TEXT_PARTS, STEP_PARTS, STOPPED_BY_USER, OpenCodeSubagents, NAMED_KINDS, OPENCODE_ABORTED_ERROR, PROVIDER_EVENT_META, TASK_TOOL_NAME, TASK_RESULT_TAG, TASK_ERROR_TAG, PERMISSION_DENIED, FILE_OPERATIONS2, PartReader, NOTHING, NON_INTERACTIVE_PERMISSIONS, CONTENT_FILTER_FINISHES, OUTPUT_PARTS, OpenCodeTurn, LISTENING, OUTPUT_TAIL_LINES, IMAGE_TYPES, OpenCodeSession, OPENCODE_MIN_VERSION, OPENCODE_REQUIREMENT, OPENCODE_TESTED_LINE, OPENCODE_SUPPORTED_MAJOR, DEFAULTS4, STORE_LOCKED, NON_INTERACTIVE_RULES, TITLE_LENGTH, MAX_VARIANT_LENGTH;
+var import_http10, import_crypto14, import_promises52, import_path10, import_path11, import_url2, import_crypto15, IDLE_SOCKET_MS3, OpenCodeHttpError, OpenCodeClient, OPENCODE_CONFIG_ENV, OPENCODE_ENGINE, TEXT_PARTS, STEP_PARTS, STOPPED_BY_USER, OpenCodeSubagents, NAMED_KINDS, OPENCODE_ABORTED_ERROR, PROVIDER_EVENT_META, TASK_TOOL_NAME, TASK_RESULT_TAG, TASK_ERROR_TAG, PERMISSION_DENIED, FILE_OPERATIONS2, PartReader, NOTHING, NON_INTERACTIVE_PERMISSIONS, CONTENT_FILTER_FINISHES, OUTPUT_PARTS, OpenCodeTurn, LISTENING, OUTPUT_TAIL_LINES, IMAGE_TYPES, OpenCodeSession, OPENCODE_MIN_VERSION, OPENCODE_REQUIREMENT, OPENCODE_TESTED_LINE, OPENCODE_SUPPORTED_MAJOR, DEFAULTS4, STORE_LOCKED, NON_INTERACTIVE_RULES, TITLE_LENGTH, MAX_VARIANT_LENGTH;
 var init_opencode = __esm({
   "../agent-core/dist/providers/opencode.js"() {
     "use strict";
@@ -45620,12 +45998,12 @@ var init_opencode = __esm({
     init_chunk_HBIPWAUI();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
-    init_chunk_FPGAN4XO();
+    init_chunk_GI3ZGXTY();
     init_chunk_YXWJW7I5();
     import_http10 = require("http");
     init_runtime_v2();
     import_crypto14 = require("crypto");
-    import_promises51 = require("fs/promises");
+    import_promises52 = require("fs/promises");
     import_path10 = require("path");
     init_agent2();
     import_path11 = require("path");
@@ -47176,7 +47554,7 @@ function droidToolCall(toolUse) {
 function droidResultText(result) {
   const blocks = asArray(result.content);
   if (blocks.length) {
-    return blocks.map((block) => asString(asRecord(block)?.text)).filter(Boolean).join("\n");
+    return blocks.map((block2) => asString(asRecord(block2)?.text)).filter(Boolean).join("\n");
   }
   const value2 = result.value;
   if (typeof value2 === "string") return value2;
@@ -47426,12 +47804,12 @@ async function droidTurnInput(run2, context) {
   const encoded = await Promise.all(
     images.map(async (image) => ({
       mimeType: image.mimeType,
-      data: (await (0, import_promises52.readFile)(image.path)).toString("base64")
+      data: (await (0, import_promises53.readFile)(image.path)).toString("base64")
     }))
   );
   return { turnId: run2.runId, text: text3, ...encoded.length ? { images: encoded } : {} };
 }
-var import_crypto16, import_promises52, FACTORY_API_VERSION, FACTORY_PROTOCOL_VERSION, SUBAGENT_TOOLS, TASK_OUTPUT_TOOLS, TASK_STOP_TOOLS, SILENT2, DroidTurn, STDERR_TAIL_LINES5, UNSUPPORTED_REQUEST2, DroidSession, DEFAULTS5, DROID_REQUIREMENT, DROID_JSONRPC_ARGS;
+var import_crypto16, import_promises53, FACTORY_API_VERSION, FACTORY_PROTOCOL_VERSION, SUBAGENT_TOOLS, TASK_OUTPUT_TOOLS, TASK_STOP_TOOLS, SILENT2, DroidTurn, STDERR_TAIL_LINES5, UNSUPPORTED_REQUEST2, DroidSession, DEFAULTS5, DROID_REQUIREMENT, DROID_JSONRPC_ARGS;
 var init_droid = __esm({
   "../agent-core/dist/providers/droid.js"() {
     "use strict";
@@ -47440,11 +47818,11 @@ var init_droid = __esm({
     init_chunk_HBIPWAUI();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
-    init_chunk_FPGAN4XO();
+    init_chunk_GI3ZGXTY();
     init_chunk_YXWJW7I5();
     init_runtime_v2();
     import_crypto16 = require("crypto");
-    import_promises52 = require("fs/promises");
+    import_promises53 = require("fs/promises");
     init_agent2();
     FACTORY_API_VERSION = "1.0.0";
     FACTORY_PROTOCOL_VERSION = "1.187.0";
@@ -47919,7 +48297,7 @@ function settingsPath(env) {
 async function readSettings2(path4) {
   let raw;
   try {
-    raw = (await (0, import_promises53.readFile)(path4, "utf8")).trim();
+    raw = (await (0, import_promises54.readFile)(path4, "utf8")).trim();
   } catch {
     return {};
   }
@@ -47937,8 +48315,8 @@ async function selectAntigravityApiKeyMode(env) {
   const settings2 = await readSettings2(path4);
   if (settings2 === "malformed") return "malformed";
   if (settings2.modelProvider === "gemini") return "already_selected";
-  await (0, import_promises53.mkdir)((0, import_path12.dirname)(path4), { recursive: true });
-  await (0, import_promises53.writeFile)(path4, JSON.stringify({ ...settings2, modelProvider: "gemini" }), { mode: 384 });
+  await (0, import_promises54.mkdir)((0, import_path12.dirname)(path4), { recursive: true });
+  await (0, import_promises54.writeFile)(path4, JSON.stringify({ ...settings2, modelProvider: "gemini" }), { mode: 384 });
   return "selected";
 }
 function readAntigravityCapabilities(version2, help) {
@@ -48537,7 +48915,7 @@ function antigravityTurnInput(run2, context) {
   });
   return { turnId: run2.runId, text: appendImagePathReferences(text3, images) };
 }
-var import_promises53, import_path12, import_fs8, import_path13, import_path14, import_url3, import_crypto17, NO_ANTIGRAVITY_CAPABILITIES, INSTRUCTIONS_FILE, MAX_INSTRUCTION_CHARS, SHORTENED_NOTE, DIFF_BLOCK_START, DIFF_BLOCK_END, HUNK_HEADER, TRANSCRIPT_FILE, FULL_TRANSCRIPT_FILE, LOG_DIRS, TOOL_RESULT_TYPES, BrainTranscript, AntigravityTranscripts, ANTIGRAVITY_GRAMMAR_NAME, AntigravityGrammar, ignored, HANDLERS, SUCCESSFUL_STATUSES, SESSION_START_TYPES, RESULT_TYPES, SUBAGENT_START_TYPES, RESUME_FORKED, EXITED_WITHOUT_RESULT, AntigravityTurn, DEFAULTS6, AntigravitySession, WINDOWS_LINE_MARGIN;
+var import_promises54, import_path12, import_fs8, import_path13, import_path14, import_url3, import_crypto17, NO_ANTIGRAVITY_CAPABILITIES, INSTRUCTIONS_FILE, MAX_INSTRUCTION_CHARS, SHORTENED_NOTE, DIFF_BLOCK_START, DIFF_BLOCK_END, HUNK_HEADER, TRANSCRIPT_FILE, FULL_TRANSCRIPT_FILE, LOG_DIRS, TOOL_RESULT_TYPES, BrainTranscript, AntigravityTranscripts, ANTIGRAVITY_GRAMMAR_NAME, AntigravityGrammar, ignored, HANDLERS, SUCCESSFUL_STATUSES, SESSION_START_TYPES, RESULT_TYPES, SUBAGENT_START_TYPES, RESUME_FORKED, EXITED_WITHOUT_RESULT, AntigravityTurn, DEFAULTS6, AntigravitySession, WINDOWS_LINE_MARGIN;
 var init_antigravity = __esm({
   "../agent-core/dist/providers/antigravity.js"() {
     "use strict";
@@ -48546,9 +48924,9 @@ var init_antigravity = __esm({
     init_chunk_XC5676SG();
     init_chunk_HBIPWAUI();
     init_chunk_M6YHY2EZ();
-    init_chunk_FPGAN4XO();
+    init_chunk_GI3ZGXTY();
     init_chunk_YXWJW7I5();
-    import_promises53 = require("fs/promises");
+    import_promises54 = require("fs/promises");
     import_path12 = require("path");
     init_type_guards();
     import_fs8 = require("fs");
@@ -49048,7 +49426,7 @@ function parseConfig(raw) {
 }
 async function writeCommandCodeProjectMcp(cwd, mcp) {
   const path4 = (0, import_path15.join)(cwd, ".mcp.json");
-  const original = await (0, import_promises54.readFile)(path4, "utf8").catch(() => null);
+  const original = await (0, import_promises55.readFile)(path4, "utf8").catch(() => null);
   const config2 = parseConfig(original);
   const next = {
     ...config2,
@@ -49065,12 +49443,12 @@ async function writeCommandCodeProjectMcp(cwd, mcp) {
       }
     }
   };
-  await (0, import_promises54.mkdir)(cwd, { recursive: true });
-  await (0, import_promises54.writeFile)(path4, `${JSON.stringify(next, null, 2)}
+  await (0, import_promises55.mkdir)(cwd, { recursive: true });
+  await (0, import_promises55.writeFile)(path4, `${JSON.stringify(next, null, 2)}
 `);
   return async () => {
-    if (original === null) await (0, import_promises54.rm)(path4, { force: true });
-    else await (0, import_promises54.writeFile)(path4, original);
+    if (original === null) await (0, import_promises55.rm)(path4, { force: true });
+    else await (0, import_promises55.writeFile)(path4, original);
   };
 }
 function commandCodeString(value2) {
@@ -49242,7 +49620,7 @@ function commandCodeTurnInput(run2, context) {
   });
   return { turnId: run2.runId, text: appendImagePathReferences(text3, images) };
 }
-var import_promises54, import_path15, import_crypto18, COMMAND_CODE_GRAMMAR_NAME, SILENT3, CommandCodeGrammar, SHELL_TOOL, STOP_TOOLS, REPORTED_STATUS, SHELL_STATUS, SWEEP_INTERVAL_MS, CommandCodeBackgroundTasks, EXITED_WITHOUT_RESULT2, CommandCodeTurn, COMMAND_CODE_MAX_TURNS, DEFAULTS7, CommandCodeSession;
+var import_promises55, import_path15, import_crypto18, COMMAND_CODE_GRAMMAR_NAME, SILENT3, CommandCodeGrammar, SHELL_TOOL, STOP_TOOLS, REPORTED_STATUS, SHELL_STATUS, SWEEP_INTERVAL_MS, CommandCodeBackgroundTasks, EXITED_WITHOUT_RESULT2, CommandCodeTurn, COMMAND_CODE_MAX_TURNS, DEFAULTS7, CommandCodeSession;
 var init_command_code = __esm({
   "../agent-core/dist/providers/command-code.js"() {
     "use strict";
@@ -49251,9 +49629,9 @@ var init_command_code = __esm({
     init_chunk_HBIPWAUI();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
-    init_chunk_FPGAN4XO();
+    init_chunk_GI3ZGXTY();
     init_chunk_YXWJW7I5();
-    import_promises54 = require("fs/promises");
+    import_promises55 = require("fs/promises");
     import_path15 = require("path");
     init_agent2();
     init_runtime_v2();
@@ -54649,7 +55027,7 @@ var require_websocket_server = __commonJS({
 // package.json
 var package_default = {
   name: "@alan-ai-hq/agent-manager",
-  version: "0.1.147",
+  version: "0.1.148",
   private: true,
   type: "module",
   description: "Alan machine runtime (alan-agent): identity, link, reconciler, session holders, run log, uploader, local API",
@@ -54699,7 +55077,7 @@ var package_default = {
 
 // src/cli/commands/compat.ts
 var import_node_crypto32 = require("crypto");
-var import_promises69 = require("fs/promises");
+var import_promises71 = require("fs/promises");
 init_runtime_v2();
 init_zod();
 
@@ -57448,9 +57826,9 @@ function isProcessAlive(pid) {
   }
 }
 async function linuxStartTime(pid) {
-  const stat22 = await (0, import_promises13.readFile)(`/proc/${pid}/stat`, "utf8").catch(() => null);
-  if (stat22 === null) return null;
-  const fields = stat22.slice(stat22.lastIndexOf(")") + 2).split(" ");
+  const stat23 = await (0, import_promises13.readFile)(`/proc/${pid}/stat`, "utf8").catch(() => null);
+  if (stat23 === null) return null;
+  const fields = stat23.slice(stat23.lastIndexOf(")") + 2).split(" ");
   return fields[19] ?? null;
 }
 async function linuxCommand(pid) {
@@ -58695,16 +59073,16 @@ function windowsManager(host, profile) {
         files.taskXml,
         Buffer.from(`${UTF8_BOM}${xml2}`, "utf16le")
       );
-      const changed = configChanged || xmlChanged;
+      const changed2 = configChanged || xmlChanged;
       const mode = await currentMode();
       const outcome2 = (manager) => ({
         manager,
         name: files.runValue,
         definitionPath: files.config,
-        changed,
+        changed: changed2,
         linger: null
       });
-      if (changed || mode === null) {
+      if (changed2 || mode === null) {
         await stopRunning(mode);
         const registered = await register2();
         await start(registered);
@@ -58933,15 +59311,15 @@ function systemdManager(host, profile) {
     name: unit,
     definitionPath: unitPath,
     install: async (spec, { restart }) => {
-      const changed = await writeDefinition(unitPath, renderSystemdUnit(spec));
-      if (changed) await runChecked(host.exec, systemctl("daemon-reload"));
+      const changed2 = await writeDefinition(unitPath, renderSystemdUnit(spec));
+      if (changed2) await runChecked(host.exec, systemctl("daemon-reload"));
       await runChecked(host.exec, systemctl("enable", unit));
-      await runChecked(host.exec, systemctlJob(changed || restart ? "restart" : "start", unit));
+      await runChecked(host.exec, systemctlJob(changed2 || restart ? "restart" : "start", unit));
       return {
         manager: "systemd",
         name: unit,
         definitionPath: unitPath,
-        changed,
+        changed: changed2,
         linger: await readLinger(host.exec, host.username)
       };
     },
@@ -59101,9 +59479,9 @@ function xdgAutostartManager(host, profile) {
         448
       );
       const entryChanged = await writeDefinition(files.entry, renderAutostartEntry(spec, files));
-      const changed = scriptChanged || entryChanged;
+      const changed2 = scriptChanged || entryChanged;
       const supervisor = await readRecordedProcess(files.supervisorRecord);
-      if (supervisor === null || changed || restart) {
+      if (supervisor === null || changed2 || restart) {
         await stopRunning();
         await start();
       }
@@ -59111,7 +59489,7 @@ function xdgAutostartManager(host, profile) {
         manager: "xdg-autostart",
         name: files.name,
         definitionPath: files.entry,
-        changed,
+        changed: changed2,
         linger: null
       };
     },
@@ -59166,16 +59544,16 @@ function launchdManager(host, profile) {
     definitionPath: plist,
     install: async (spec, { restart }) => {
       await (0, import_promises23.mkdir)((0, import_node_path20.dirname)(spec.logPath), { recursive: true, mode: 448 });
-      const changed = await writeDefinition(plist, renderLaunchdPlist(spec));
+      const changed2 = await writeDefinition(plist, renderLaunchdPlist(spec));
       const loaded = await isLoaded();
-      if (loaded && !changed) {
+      if (loaded && !changed2) {
         await runChecked(host.exec, launchctl("kickstart", ...restart ? ["-k"] : [], target));
-        return { manager: "launchd", name: label, definitionPath: plist, changed, linger: null };
+        return { manager: "launchd", name: label, definitionPath: plist, changed: changed2, linger: null };
       }
       if (loaded) await host.exec(launchctl("bootout", target));
       await host.exec(launchctl("enable", target));
       await runChecked(host.exec, launchctl("bootstrap", domain2, plist));
-      return { manager: "launchd", name: label, definitionPath: plist, changed, linger: null };
+      return { manager: "launchd", name: label, definitionPath: plist, changed: changed2, linger: null };
     },
     uninstall: async () => {
       const loaded = await isLoaded();
@@ -61312,10 +61690,10 @@ function openCodeScanFromVerbose(text3) {
     const id = (lines2[index] ?? "").trim();
     index += 1;
     if (!isProviderSlashModelId(id)) continue;
-    const block = readJsonBlock(lines2, index);
-    if (block === null) continue;
-    index = block.end + 1;
-    const entry = parseVerboseEntry(block.json);
+    const block2 = readJsonBlock(lines2, index);
+    if (block2 === null) continue;
+    index = block2.end + 1;
+    const entry = parseVerboseEntry(block2.json);
     if (entry === null) continue;
     if (entry.status === "deprecated") deprecated.add(id);
     else models.push(verboseModel(id, entry));
@@ -61689,9 +62067,9 @@ function installIngestionHooks(provider4, options, now) {
     ];
   }
   const next = { ...settings2, hooks: nextHooks };
-  const changed = JSON.stringify(next) !== JSON.stringify(settings2);
-  if (changed) writeSettings(path4, next);
-  return { provider: provider4, path: path4, changed };
+  const changed2 = JSON.stringify(next) !== JSON.stringify(settings2);
+  if (changed2) writeSettings(path4, next);
+  return { provider: provider4, path: path4, changed: changed2 };
 }
 function removeIngestionHooks(provider4, where, now) {
   const path4 = providerHookSettingsPath(provider4, where);
@@ -61699,18 +62077,18 @@ function removeIngestionHooks(provider4, where, now) {
   const settings2 = readSettings(path4, true, now);
   const hooks = hooksOf(settings2);
   const nextHooks = {};
-  let changed = false;
+  let changed2 = false;
   for (const [event, groups] of Object.entries(hooks)) {
     if (!hasHandler(groups, isIngestionHandler)) {
       nextHooks[event] = groups;
       continue;
     }
-    changed = true;
+    changed2 = true;
     const retained = withoutIngestionHandlers(groups, path4, event);
     if (retained.length > 0) nextHooks[event] = retained;
   }
-  if (changed) writeSettings(path4, { ...settings2, hooks: nextHooks });
-  return { provider: provider4, path: path4, changed };
+  if (changed2) writeSettings(path4, { ...settings2, hooks: nextHooks });
+  return { provider: provider4, path: path4, changed: changed2 };
 }
 function ingestionHooksInstalled(provider4, where) {
   const hooks = hooksOf(readSettings(providerHookSettingsPath(provider4, where), false, 0));
@@ -62146,18 +62524,18 @@ async function readTranscriptWindow(path4, offset, limits) {
         limits.maxRecordBytes,
         Math.max(limits.windowBytes - gathered, MIN_READ_BYTES)
       );
-      const block = await readCompleteLines(
+      const block2 = await readCompleteLines(
         handle,
         position,
         size,
         firstReadBytes,
         limits.maxRecordBytes
       );
-      const recordEnd = block.oversized ? await findRecordEnd(handle, block.scannedEnd, size) : null;
-      if (block.lines.length > 0) {
-        pieces.push(block.lines);
-        gathered += block.lines.length;
-        position += block.lines.length;
+      const recordEnd = block2.oversized ? await findRecordEnd(handle, block2.scannedEnd, size) : null;
+      if (block2.lines.length > 0) {
+        pieces.push(block2.lines);
+        gathered += block2.lines.length;
+        position += block2.lines.length;
       } else if (recordEnd !== null) {
         pieces.push(SKIPPED_RECORD_LINE);
         skipped.push({ offset: position, bytes: recordEnd - position });
@@ -62199,7 +62577,7 @@ function textOf(update) {
     return update.content.type === "text" ? update.content.text : "";
   }
   if (isUpdate(update, "agent_message")) {
-    return (update.content ?? []).map((block) => block.type === "text" ? block.text : "").join("");
+    return (update.content ?? []).map((block2) => block2.type === "text" ? block2.text : "").join("");
   }
   return "";
 }
@@ -63170,6 +63548,7 @@ function captureProbe(command, args, options) {
 }
 
 // src/capabilities/providers/inventory.ts
+var import_promises36 = require("fs/promises");
 var import_node_os3 = require("os");
 init_runtime_v2();
 
@@ -63473,6 +63852,42 @@ ${output2.stderr}`)) {
 }
 
 // src/capabilities/providers/inventory.ts
+var PROBE_CONCURRENCY = 4;
+function createProbeQueue(capture, env, limit) {
+  let active = 0;
+  const waiting = [];
+  const shared = /* @__PURE__ */ new Map();
+  const acquire = () => {
+    if (active < limit) {
+      active += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve14) => waiting.push(resolve14));
+  };
+  const release2 = () => {
+    const next = waiting.shift();
+    if (next === void 0) active -= 1;
+    else next();
+  };
+  const run2 = async (task) => {
+    await acquire();
+    try {
+      return await task();
+    } finally {
+      release2();
+    }
+  };
+  const limited = (command, args, options) => {
+    if (options.env !== env) return run2(() => capture(command, args, options));
+    const key = [command, ...args].join("\0");
+    const existing = shared.get(key);
+    if (existing !== void 0) return existing;
+    const output2 = run2(() => capture(command, args, options));
+    shared.set(key, output2);
+    return output2;
+  };
+  return { capture: limited, run: run2 };
+}
 function readMachineFacts(platform3, runtimeVersion) {
   return machineFactsSchema.parse({
     os: platform3,
@@ -63497,11 +63912,11 @@ function runFacts(run2) {
       return {};
   }
 }
-async function scanProvider(provider4, options, capture) {
+async function scanProvider(provider4, options, queue) {
   const { env, platform: platform3, clock } = options;
   const executable = await resolveProviderExecutable(provider4, env, platform3);
   if (executable !== null && provider4.backendKind === ALAN_CODE_BACKEND) {
-    return scanAlanCode(executable, options, capture);
+    return scanAlanCode(executable, options, queue.capture);
   }
   if (executable === null || !options.probes) {
     return {
@@ -63511,14 +63926,14 @@ async function scanProvider(provider4, options, capture) {
       checkedAt: clock.now()
     };
   }
-  const authResult = probeAuth(provider4.backendKind, provider4.name, executable, env, capture);
+  const authResult = probeAuth(provider4.backendKind, provider4.name, executable, env, queue.capture);
   const accountLabelProbe = options.accountLabelProbe ?? (options.capture === void 0 ? probeAccountLabel : async () => void 0);
   const [run2, auth, models, authLabel] = await Promise.all([
-    probeRun(executable, env, capture),
+    probeRun(executable, env, queue.capture),
     authResult,
-    discoverProviderModels(provider4, executable, options, capture),
+    discoverProviderModels(provider4, executable, options, queue.capture),
     authResult.then(
-      (result) => result.auth === "signed_in" ? accountLabelProbe(provider4.backendKind, executable, env, capture).catch(() => void 0) : void 0
+      (result) => result.auth === "signed_in" ? queue.run(() => accountLabelProbe(provider4.backendKind, executable, env, queue.capture)).catch(() => void 0) : void 0
     )
   ]);
   return {
@@ -63566,9 +63981,9 @@ async function scanAlanCode(executable, options, capture) {
   };
 }
 async function scanCapabilities(options) {
-  const capture = options.capture ?? captureProbe;
+  const queue = createProbeQueue(options.capture ?? captureProbe, options.env, PROBE_CONCURRENCY);
   const [providers, hasGit] = await Promise.all([
-    Promise.all(PROVIDER_COMMANDS.map((provider4) => scanProvider(provider4, options, capture))),
+    Promise.all(PROVIDER_COMMANDS.map((provider4) => scanProvider(provider4, options, queue))),
     isCommandOnPath("git", options.env, options.platform)
   ]);
   return {
@@ -63586,23 +64001,61 @@ function sameCapabilities(a, b) {
   });
   return comparable(a) === comparable(b);
 }
+async function executablesFingerprint(env, platform3) {
+  const entries = await Promise.all(
+    PROVIDER_COMMANDS.map(async (provider4) => {
+      const executable = await resolveProviderExecutable(provider4, env, platform3);
+      if (executable === null) return `${provider4.backendKind}:-`;
+      try {
+        const target = await (0, import_promises36.realpath)(executable);
+        const { size, mtimeMs } = await (0, import_promises36.stat)(target);
+        return `${provider4.backendKind}:${target}:${size}:${mtimeMs}`;
+      } catch {
+        return `${provider4.backendKind}:${executable}:?`;
+      }
+    })
+  );
+  return entries.join("\n");
+}
 function createCapabilityInventory(options) {
   let last = null;
   let running = null;
-  const rescan = () => {
-    running ??= scanCapabilities({ ...options, env: options.env() }).then((capabilities) => {
-      last = capabilities;
+  const rescan = (reason) => {
+    running ??= (async () => {
+      const startedAt = options.clock.monotonic();
+      const env = options.env();
+      const fingerprint = await executablesFingerprint(env, options.platform);
+      const capabilities = await scanCapabilities({ ...options, env });
+      last = { capabilities, fingerprint };
+      options.log.info("capabilities.scanned", {
+        reason,
+        durationMs: Math.round(options.clock.monotonic() - startedAt)
+      });
       return capabilities;
-    }).finally(() => {
+    })().finally(() => {
       running = null;
     });
     return running;
   };
+  const youngerThan = (scan, ageMs) => options.clock.now() - scan.capabilities.scannedAt < ageMs;
   return {
     scan: ({ refresh }) => {
       if (running !== null) return running;
-      const fresh = last !== null && options.clock.now() - last.scannedAt < options.maxAgeMs;
-      return !refresh && fresh && last !== null ? Promise.resolve(last) : rescan();
+      if (refresh) return rescan("requested");
+      return last !== null && youngerThan(last, options.maxAgeMs) ? Promise.resolve(last.capabilities) : rescan("expired");
+    },
+    latest: () => {
+      if (running !== null) return running;
+      return last === null ? rescan("first") : Promise.resolve(last.capabilities);
+    },
+    rescanIfChanged: async () => {
+      if (running !== null) return running;
+      const previous = last;
+      if (previous === null) return rescan("first");
+      if (!youngerThan(previous, options.staleAfterMs)) return rescan("stale");
+      const fingerprint = await executablesFingerprint(options.env(), options.platform);
+      if (running !== null) return running;
+      return fingerprint === previous.fingerprint ? previous.capabilities : rescan("cli_changed");
     }
   };
 }
@@ -63863,16 +64316,16 @@ async function openCliEnvironment(options) {
       if (options.clock.now() < retryAt) return false;
       retryAt = options.clock.now() + DEGRADED_RETRY_MS;
       const next = await resolve14();
-      const changed = envValue(next.env, "PATH") !== envValue(state.env, "PATH");
+      const changed2 = envValue(next.env, "PATH") !== envValue(state.env, "PATH");
       state = next;
-      return changed;
+      return changed2;
     }
   };
 }
 
 // src/capabilities/providers/managed.ts
 var import_node_crypto17 = require("crypto");
-var import_promises36 = require("fs/promises");
+var import_promises37 = require("fs/promises");
 var import_node_path38 = require("path");
 init_zod();
 var PACKAGES = {
@@ -63889,7 +64342,7 @@ var VERSION = /^[0-9]+\.[0-9]+\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$/;
 var selectedSchema = external_exports.record(external_exports.string(), external_exports.string());
 async function readManagedProviderVersion(file2, backendKind) {
   try {
-    const selected = selectedSchema.parse(JSON.parse(await (0, import_promises36.readFile)(file2, "utf8")));
+    const selected = selectedSchema.parse(JSON.parse(await (0, import_promises37.readFile)(file2, "utf8")));
     const version2 = selected[backendKind];
     return version2 !== void 0 && VERSION.test(version2) ? version2 : null;
   } catch {
@@ -63956,7 +64409,7 @@ function selection(root, backendKind, version2) {
   };
 }
 async function runnable(file2) {
-  return (0, import_promises36.stat)(file2).then(
+  return (0, import_promises37.stat)(file2).then(
     (value2) => value2.isFile(),
     () => false
   );
@@ -63999,13 +64452,13 @@ function createManagedProviderClis(options) {
     return next;
   };
   const persist = async () => {
-    await (0, import_promises36.mkdir)(options.root, { recursive: true, mode: 448 });
+    await (0, import_promises37.mkdir)(options.root, { recursive: true, mode: 448 });
     const staged = `${file2}.${(0, import_node_crypto17.randomUUID)()}`;
     try {
-      await (0, import_promises36.writeFile)(staged, JSON.stringify(state), { mode: 384 });
-      await (0, import_promises36.rename)(staged, file2);
+      await (0, import_promises37.writeFile)(staged, JSON.stringify(state), { mode: 384 });
+      await (0, import_promises37.rename)(staged, file2);
     } finally {
-      await (0, import_promises36.rm)(staged, { force: true });
+      await (0, import_promises37.rm)(staged, { force: true });
     }
   };
   const activate = async (backendKind, version2) => {
@@ -64027,7 +64480,7 @@ function createManagedProviderClis(options) {
   return {
     selectionFile: file2,
     load: async () => {
-      const raw = await (0, import_promises36.readFile)(file2, "utf8").catch((error61) => {
+      const raw = await (0, import_promises37.readFile)(file2, "utf8").catch((error61) => {
         if (error61 instanceof Error && "code" in error61 && error61.code === "ENOENT") return "{}";
         throw error61;
       });
@@ -64035,7 +64488,7 @@ function createManagedProviderClis(options) {
       try {
         parsed = selectedSchema.parse(JSON.parse(raw));
       } catch {
-        await (0, import_promises36.rename)(file2, `${file2}.invalid.${(0, import_node_crypto17.randomUUID)()}`).catch(() => void 0);
+        await (0, import_promises37.rename)(file2, `${file2}.invalid.${(0, import_node_crypto17.randomUUID)()}`).catch(() => void 0);
         return;
       }
       for (const [backendKind, version2] of Object.entries(parsed)) {
@@ -64055,7 +64508,7 @@ function createManagedProviderClis(options) {
       const groups = await Promise.all(
         Object.keys(PACKAGES).map(async (backendKind) => {
           const directory = (0, import_node_path38.join)(options.root, "versions", backendKind);
-          const versions = await (0, import_promises36.readdir)(directory).catch((error61) => {
+          const versions = await (0, import_promises37.readdir)(directory).catch((error61) => {
             if (error61 instanceof Error && "code" in error61 && error61.code === "ENOENT") return [];
             throw error61;
           });
@@ -64092,7 +64545,7 @@ function createManagedProviderClis(options) {
       const target = (0, import_node_path38.join)(options.root, "versions", backendKind, exact);
       const existing = selection(options.root, backendKind, exact);
       if (!await runnable(existing.executable) || !await options.probe(existing.executable, backendKind)) {
-        await (0, import_promises36.mkdir)((0, import_node_path38.dirname)(target), { recursive: true, mode: 448 });
+        await (0, import_promises37.mkdir)((0, import_node_path38.dirname)(target), { recursive: true, mode: 448 });
         const staged = `${target}.${(0, import_node_crypto17.randomUUID)()}`;
         try {
           await options.installPackage(provider4.name, exact, staged, provider4.command, signal);
@@ -64100,10 +64553,10 @@ function createManagedProviderClis(options) {
           if (!await runnable(built) || !await options.probe(built, backendKind)) {
             throw new Error(`${backendKind}@${exact} failed its executable probe`);
           }
-          await (0, import_promises36.rm)(target, { recursive: true, force: true });
-          await (0, import_promises36.rename)(staged, target);
+          await (0, import_promises37.rm)(target, { recursive: true, force: true });
+          await (0, import_promises37.rename)(staged, target);
         } finally {
-          await (0, import_promises36.rm)(staged, { recursive: true, force: true });
+          await (0, import_promises37.rm)(staged, { recursive: true, force: true });
         }
       }
       return activate(backendKind, exact);
@@ -64206,13 +64659,13 @@ ${help.stderr}`);
 }
 
 // src/capabilities/skills/local-preview.ts
-var import_promises41 = require("fs/promises");
+var import_promises42 = require("fs/promises");
 var import_node_path43 = __toESM(require("path"));
 
 // ../shared/dist/node/skill-package.js
 var import_node_buffer = require("buffer");
 var import_node_crypto18 = require("crypto");
-var import_promises37 = require("fs/promises");
+var import_promises38 = require("fs/promises");
 var import_node_path39 = require("path");
 var import_yaml = __toESM(require_dist(), 1);
 init_contracts();
@@ -64308,11 +64761,11 @@ async function readSkillPackageFile(packageRoot, path4, expectedSha256) {
   if (!normalizedPath || normalizedPath !== path4 || normalizedPath.includes("\\") || components.some((component) => !component || component === "." || component === "..")) {
     throw new SkillPackageError("INVALID_PATH", `Invalid Skill package path: ${path4}`, path4);
   }
-  const absolutePath = await (0, import_promises37.realpath)((0, import_node_path39.resolve)(root, ...components)).catch(() => null);
+  const absolutePath = await (0, import_promises38.realpath)((0, import_node_path39.resolve)(root, ...components)).catch(() => null);
   if (!absolutePath || normalizeRelativePath(root, absolutePath) !== normalizedPath) {
     throw new SkillPackageError("INVALID_PATH", `Skill package file was not found: ${path4}`, path4);
   }
-  const entryStat = await (0, import_promises37.lstat)(absolutePath);
+  const entryStat = await (0, import_promises38.lstat)(absolutePath);
   if (!entryStat.isFile()) {
     throw new SkillPackageError("SPECIAL_FILE_BLOCKED", `Only regular files are allowed in Skill packages: ${path4}`, path4);
   }
@@ -64329,11 +64782,11 @@ async function readSkillPackageFile(packageRoot, path4, expectedSha256) {
   return { file: read.manifest, bytes: read.bytes };
 }
 async function requirePackageRoot(packageRoot) {
-  const root = await (0, import_promises37.realpath)((0, import_node_path39.resolve)(packageRoot)).catch(() => null);
+  const root = await (0, import_promises38.realpath)((0, import_node_path39.resolve)(packageRoot)).catch(() => null);
   if (!root) {
     throw new SkillPackageError("INVALID_PACKAGE_ROOT", "Skill package directory does not exist");
   }
-  const rootStat = await (0, import_promises37.lstat)(root);
+  const rootStat = await (0, import_promises38.lstat)(root);
   if (!rootStat.isDirectory()) {
     throw new SkillPackageError("INVALID_PACKAGE_ROOT", "Skill package root must be a directory");
   }
@@ -64353,13 +64806,13 @@ async function walkPackage(root, ignoredPaths) {
   }
   return files;
   async function walkDirectory(directory) {
-    const entries = await (0, import_promises37.readdir)(directory, { withFileTypes: true });
+    const entries = await (0, import_promises38.readdir)(directory, { withFileTypes: true });
     for (const entry of entries) {
       const absolutePath = (0, import_node_path39.resolve)(directory, entry.name);
       const normalizedPath = normalizeRelativePath(root, absolutePath);
       if (isIgnored(normalizedPath, entry.name, entry.isDirectory(), ignored2))
         continue;
-      const entryStat = await (0, import_promises37.lstat)(absolutePath);
+      const entryStat = await (0, import_promises38.lstat)(absolutePath);
       if (entryStat.isSymbolicLink()) {
         throw new SkillPackageError("SYMLINK_BLOCKED", `Nested symbolic links are not allowed in Skill packages: ${normalizedPath}`, normalizedPath);
       }
@@ -64468,7 +64921,7 @@ function isSecretPath(path4) {
   return name.endsWith(".private-key.pem") || name.endsWith(".private-key.key");
 }
 async function readPackageFile(file2) {
-  const bytes = await (0, import_promises37.readFile)(file2.absolutePath);
+  const bytes = await (0, import_promises38.readFile)(file2.absolutePath);
   return {
     bytes,
     manifest: {
@@ -64639,13 +65092,13 @@ function uint642(value2) {
 
 // src/capabilities/skills/local-sources.ts
 var import_node_crypto20 = require("crypto");
-var import_promises39 = require("fs/promises");
+var import_promises40 = require("fs/promises");
 var import_node_path41 = __toESM(require("path"));
 init_type_guards();
 
 // src/capabilities/skills/local-scan.ts
 var import_node_crypto19 = require("crypto");
-var import_promises38 = require("fs/promises");
+var import_promises39 = require("fs/promises");
 var import_node_path40 = __toESM(require("path"));
 var MAX_CANDIDATES = 2e3;
 var MAX_DIAGNOSTICS = 100;
@@ -64766,7 +65219,7 @@ function invalid(resolvedRoot, name, error61) {
 }
 async function scanRootAsPackage(pass, resolvedRoot) {
   if (!await exists3(import_node_path40.default.join(resolvedRoot.directory, "SKILL.md"))) return null;
-  const canonical = await (0, import_promises38.realpath)(resolvedRoot.directory).catch(() => resolvedRoot.directory);
+  const canonical = await (0, import_promises39.realpath)(resolvedRoot.directory).catch(() => resolvedRoot.directory);
   if (isManaged(pass, canonical)) return { candidates: [], diagnostics: [], incomplete: false };
   try {
     const inspected = await inspectCached(pass, canonical, null);
@@ -64796,7 +65249,7 @@ async function scanRoot(pass, resolvedRoot) {
   if (asPackage !== null) return asPackage;
   let entries;
   try {
-    entries = await (0, import_promises38.readdir)(resolvedRoot.directory, { withFileTypes: true });
+    entries = await (0, import_promises39.readdir)(resolvedRoot.directory, { withFileTypes: true });
   } catch (error61) {
     const code = errnoCode(error61);
     if (code === "ENOENT" || code === "ENOTDIR") {
@@ -64814,7 +65267,7 @@ async function scanRoot(pass, resolvedRoot) {
       incomplete: true
     };
   }
-  const canonicalRoot = await (0, import_promises38.realpath)(resolvedRoot.directory).catch(() => resolvedRoot.directory);
+  const canonicalRoot = await (0, import_promises39.realpath)(resolvedRoot.directory).catch(() => resolvedRoot.directory);
   const scan = { candidates: [], diagnostics: [], incomplete: false };
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
@@ -64826,7 +65279,7 @@ async function scanRoot(pass, resolvedRoot) {
 }
 async function scanEntry(pass, resolvedRoot, canonicalRoot, name) {
   const rootLabel = resolvedRoot.root.label;
-  const canonical = await (0, import_promises38.realpath)(import_node_path40.default.join(resolvedRoot.directory, name)).catch(() => null);
+  const canonical = await (0, import_promises39.realpath)(import_node_path40.default.join(resolvedRoot.directory, name)).catch(() => null);
   if (canonical === null) {
     const message2 = `Could not resolve Skill ${name}`;
     return { kind: "diagnostic", diagnostic: { code: "SOURCE_UNREADABLE", message: message2, rootLabel } };
@@ -64911,12 +65364,12 @@ function deduplicateByContent(candidates2) {
 async function fingerprintPackage(root) {
   const hash2 = (0, import_node_crypto19.createHash)("sha256").update("alan-skill-stat-fingerprint-v1\0");
   const visit2 = async (directory, relativeDirectory) => {
-    const entries = await (0, import_promises38.readdir)(directory, { withFileTypes: true });
+    const entries = await (0, import_promises39.readdir)(directory, { withFileTypes: true });
     entries.sort((left, right) => Buffer.compare(Buffer.from(left.name), Buffer.from(right.name)));
     for (const entry of entries) {
       const relative6 = relativeDirectory ? `${relativeDirectory}/${entry.name}` : entry.name;
       const absolute = import_node_path40.default.join(directory, entry.name);
-      const metadata = await (0, import_promises38.lstat)(absolute);
+      const metadata = await (0, import_promises39.lstat)(absolute);
       const kind = entryKind(entry);
       hash2.update(relative6.normalize("NFC")).update(`\0${kind}\0${metadata.size}\0${metadata.mtimeMs}\0${metadata.mode & 511}\0`);
       if (entry.isDirectory()) await visit2(absolute, relative6);
@@ -64932,7 +65385,7 @@ function entryKind(entry) {
 }
 async function canonicalDirectories(directories) {
   const canonical = await Promise.all(
-    directories.map((directory) => (0, import_promises38.realpath)(directory).catch(() => directory))
+    directories.map((directory) => (0, import_promises39.realpath)(directory).catch(() => directory))
   );
   return [...new Set(canonical)];
 }
@@ -64945,7 +65398,7 @@ function isWithinDirectory2(parent, candidate) {
 }
 async function exists3(candidate) {
   try {
-    await (0, import_promises38.access)(candidate);
+    await (0, import_promises39.access)(candidate);
     return true;
   } catch {
     return false;
@@ -64953,7 +65406,7 @@ async function exists3(candidate) {
 }
 async function isDirectory3(candidate) {
   try {
-    return (await (0, import_promises38.lstat)(candidate)).isDirectory();
+    return (await (0, import_promises39.lstat)(candidate)).isDirectory();
   } catch {
     return false;
   }
@@ -65041,7 +65494,7 @@ async function resolveLocalScanInput(home, context, mode) {
 async function readSkillSourceConfig(home) {
   let content;
   try {
-    content = await (0, import_promises39.readFile)(skillSourceConfigPath(home), "utf8");
+    content = await (0, import_promises40.readFile)(skillSourceConfigPath(home), "utf8");
   } catch (error61) {
     if (errnoCode(error61) !== "ENOENT") {
       return { kind: "invalid_config", diagnostic: "~/.alan/config.toml could not be read" };
@@ -65158,7 +65611,7 @@ async function scanLocalSkills(home, context, cache2, mode = "incremental", mana
 }
 
 // src/capabilities/skills/store.ts
-var import_promises40 = require("fs/promises");
+var import_promises41 = require("fs/promises");
 var import_node_path42 = require("path");
 
 // ../shared/dist/node/alan-skill-identity.js
@@ -65229,7 +65682,7 @@ function writeLocalSkills(layout, file2) {
 async function isLocalSkillCurrent(entry, contentHash, ignoredPaths) {
   if (entry.contentHash !== contentHash) return false;
   try {
-    if (await (0, import_promises40.realpath)(entry.path) !== entry.path) return false;
+    if (await (0, import_promises41.realpath)(entry.path) !== entry.path) return false;
     const inspected = await inspectSkillPackage(entry.path, { expectedName: null, ignoredPaths });
     return inspected.contentHash === contentHash;
   } catch {
@@ -65244,7 +65697,7 @@ async function resolveLocalSkill(local, invocation) {
 }
 async function hasSkillFile(directory) {
   try {
-    return (await (0, import_promises40.stat)((0, import_node_path42.join)(directory, "SKILL.md"))).isFile();
+    return (await (0, import_promises41.stat)((0, import_node_path42.join)(directory, "SKILL.md"))).isFile();
   } catch {
     return false;
   }
@@ -65308,7 +65761,7 @@ async function availableSkillIndex(layout) {
     });
   }
   if (layout.nativeDir !== null) {
-    const entries = await (0, import_promises40.readdir)(layout.nativeDir, { withFileTypes: true }).catch(() => []);
+    const entries = await (0, import_promises41.readdir)(layout.nativeDir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isDirectory() || entry.isSymbolicLink())
         candidates2.push({ directory: (0, import_node_path42.join)(layout.nativeDir, entry.name) });
@@ -65399,7 +65852,7 @@ async function readLocalSkillFile(layout, ref) {
 }
 async function isDirectory4(candidate) {
   try {
-    return (await (0, import_promises41.stat)(candidate)).isDirectory();
+    return (await (0, import_promises42.stat)(candidate)).isDirectory();
   } catch {
     return false;
   }
@@ -65412,29 +65865,29 @@ async function addSkillSource(home, input2) {
     return { state: "invalid", diagnostic: `${sourcePath} is not a folder` };
   }
   const configPath = skillSourceConfigPath(home);
-  await (0, import_promises41.mkdir)(import_node_path43.default.dirname(configPath), { recursive: true, mode: 448 });
-  await (0, import_promises41.writeFile)(configPath, DEFAULT_SKILL_CONFIG, { flag: "wx", mode: 384 }).catch(
+  await (0, import_promises42.mkdir)(import_node_path43.default.dirname(configPath), { recursive: true, mode: 448 });
+  await (0, import_promises42.writeFile)(configPath, DEFAULT_SKILL_CONFIG, { flag: "wx", mode: 384 }).catch(
     (error61) => {
       if (errnoCode(error61) !== "EEXIST") throw error61;
     }
   );
   const loaded = await readSkillSourceConfig(home);
   if (loaded.kind === "invalid_config") return { state: "invalid", diagnostic: loaded.diagnostic };
-  const canonical = await (0, import_promises41.realpath)(sourcePath).catch(() => sourcePath);
+  const canonical = await (0, import_promises42.realpath)(sourcePath).catch(() => sourcePath);
   for (const source of loaded.config.sources) {
-    if (await (0, import_promises41.realpath)(source.path).catch(() => source.path) === canonical) {
+    if (await (0, import_promises42.realpath)(source.path).catch(() => source.path) === canonical) {
       return { state: "already_present", label: source.label };
     }
   }
-  const current = await (0, import_promises41.readFile)(configPath, "utf8");
-  const block = [
+  const current = await (0, import_promises42.readFile)(configPath, "utf8");
+  const block2 = [
     "",
     "[[skills.sources]]",
     `path = ${JSON.stringify(sourcePath)}`,
     `label = ${JSON.stringify(label)}`,
     ""
   ].join("\n");
-  await (0, import_promises41.writeFile)(configPath, `${current.replace(/\n*$/, "\n")}${block}`, { mode: 384 });
+  await (0, import_promises42.writeFile)(configPath, `${current.replace(/\n*$/, "\n")}${block2}`, { mode: 384 });
   const reloaded = await readSkillSourceConfig(home);
   if (reloaded.kind === "invalid_config") {
     return { state: "invalid", diagnostic: reloaded.diagnostic };
@@ -65443,12 +65896,12 @@ async function addSkillSource(home, input2) {
 }
 
 // src/capabilities/skills/local-upload.ts
-var import_promises43 = require("fs/promises");
+var import_promises44 = require("fs/promises");
 
 // ../shared/dist/node/skill-bundle.js
 var import_node_buffer2 = require("buffer");
 var import_node_crypto22 = require("crypto");
-var import_promises42 = require("fs/promises");
+var import_promises43 = require("fs/promises");
 var import_node_path44 = require("path");
 var import_node_stream = require("stream");
 var import_node_zlib = require("zlib");
@@ -65459,7 +65912,7 @@ async function createSkillBundle(packageRoot, options = {}) {
   const archive = (0, import_tar_stream.pack)();
   const tarPromise = collectStream(archive);
   for (const file2 of before.files) {
-    const bytes2 = await (0, import_promises42.readFile)((0, import_node_path44.join)(packageRoot, ...file2.path.split("/")));
+    const bytes2 = await (0, import_promises43.readFile)((0, import_node_path44.join)(packageRoot, ...file2.path.split("/")));
     await addArchiveEntry(archive, {
       name: file2.path,
       type: "file",
@@ -65491,7 +65944,7 @@ async function extractSkillBundle(archiveBytes, destination, expected) {
     throw new Error("Skill archive hash does not match the expected immutable Version");
   }
   const tarBytes = await decompressBounded(archiveBytes);
-  await (0, import_promises42.mkdir)(destination, { recursive: false, mode: 448 });
+  await (0, import_promises43.mkdir)(destination, { recursive: false, mode: 448 });
   try {
     await extractTar(tarBytes, destination);
     const inspected = await inspectSkillPackage(destination, { expectedName: null });
@@ -65499,7 +65952,7 @@ async function extractSkillBundle(archiveBytes, destination, expected) {
       throw new Error("Extracted Skill package hash does not match the expected immutable Version");
     }
   } catch (error61) {
-    await (0, import_promises42.rm)(destination, { recursive: true, force: true });
+    await (0, import_promises43.rm)(destination, { recursive: true, force: true });
     throw error61;
   }
 }
@@ -65575,8 +66028,8 @@ async function extractEntry(header, stream, destination, limits) {
     throw new Error(`Skill archive file size is invalid: ${path4}`);
   }
   const outputPath = (0, import_node_path44.join)(destination, ...path4.split("/"));
-  await (0, import_promises42.mkdir)((0, import_node_path44.dirname)(outputPath), { recursive: true, mode: 448 });
-  await (0, import_promises42.writeFile)(outputPath, bytes, { mode: (header.mode ?? 420) & 73 ? 493 : 420 });
+  await (0, import_promises43.mkdir)((0, import_node_path44.dirname)(outputPath), { recursive: true, mode: 448 });
+  await (0, import_promises43.writeFile)(outputPath, bytes, { mode: (header.mode ?? 420) & 73 ? 493 : 420 });
 }
 function requireSafeArchivePath(value2) {
   const normalized2 = value2.replaceAll("\\", "/").normalize("NFC");
@@ -65602,8 +66055,8 @@ async function publishLocalSkill(options) {
   if (Date.parse(request2.uploadGrant.expiresAt) <= (options.now ?? Date.now())) {
     throw new RuntimeFault("invalid_file", "Skill upload grant expired");
   }
-  const folder = await (0, import_promises43.lstat)(entry.path);
-  if (!folder.isDirectory() || await (0, import_promises43.realpath)(entry.path) !== entry.path) {
+  const folder = await (0, import_promises44.lstat)(entry.path);
+  if (!folder.isDirectory() || await (0, import_promises44.realpath)(entry.path) !== entry.path) {
     throw new RuntimeFault("invalid_file", "Skill folder moved since the last scan");
   }
   const bundle = await createSkillBundle(entry.path, {
@@ -65632,7 +66085,7 @@ async function publishLocalSkill(options) {
 // src/capabilities/skills/native-index.ts
 var import_node_crypto23 = require("crypto");
 var import_node_fs16 = require("fs");
-var import_promises44 = require("fs/promises");
+var import_promises45 = require("fs/promises");
 var import_node_path45 = require("path");
 var ALAN_SKILLS_PLUGIN_NAME = "alan";
 var PLUGIN_MANIFEST = `${JSON.stringify(
@@ -65646,32 +66099,32 @@ var PLUGIN_MANIFEST = `${JSON.stringify(
 `;
 async function entryKind2(path4) {
   try {
-    return (await (0, import_promises44.lstat)(path4)).isSymbolicLink() ? "link" : "other";
+    return (await (0, import_promises45.lstat)(path4)).isSymbolicLink() ? "link" : "other";
   } catch (error61) {
     if (errnoCode(error61) === "ENOENT") return "missing";
     throw error61;
   }
 }
 async function linkTarget(path4) {
-  return (0, import_promises44.readlink)(path4).catch(() => null);
+  return (0, import_promises45.readlink)(path4).catch(() => null);
 }
 async function removeLink(path4) {
   try {
-    await (0, import_promises44.unlink)(path4);
+    await (0, import_promises45.unlink)(path4);
   } catch (error61) {
     const code = errnoCode(error61);
     if (code === "ENOENT") return;
     if (code !== "EPERM" && code !== "EISDIR") throw error61;
-    await (0, import_promises44.rmdir)(path4);
+    await (0, import_promises45.rmdir)(path4);
   }
 }
 async function placeLink(plan2, platform3) {
   if (await linkTarget(plan2.path) === plan2.target) return false;
   const staged = (0, import_node_path45.join)((0, import_node_path45.dirname)(plan2.path), `.${(0, import_node_path45.basename)(plan2.path)}.${(0, import_node_crypto23.randomUUID)()}.tmp`);
-  await (0, import_promises44.symlink)(plan2.target, staged, platform3 === "win32" ? "junction" : "dir");
+  await (0, import_promises45.symlink)(plan2.target, staged, platform3 === "win32" ? "junction" : "dir");
   try {
     if (platform3 === "win32") await removeLink(plan2.path);
-    await (0, import_promises44.rename)(staged, plan2.path);
+    await (0, import_promises45.rename)(staged, plan2.path);
   } catch (error61) {
     await removeLink(staged).catch(() => void 0);
     throw error61;
@@ -65684,14 +66137,14 @@ function versionTarget(layout, versionId, platform3) {
 }
 async function writeManifest(layout) {
   const manifest = (0, import_node_path45.join)(layout.pluginDir, ".claude-plugin", "plugin.json");
-  if (await (0, import_promises44.readFile)(manifest, "utf8").catch(() => null) === PLUGIN_MANIFEST) return;
-  await (0, import_promises44.mkdir)((0, import_node_path45.dirname)(manifest), { recursive: true, mode: 448 });
+  if (await (0, import_promises45.readFile)(manifest, "utf8").catch(() => null) === PLUGIN_MANIFEST) return;
+  await (0, import_promises45.mkdir)((0, import_node_path45.dirname)(manifest), { recursive: true, mode: 448 });
   const staged = `${manifest}.${(0, import_node_crypto23.randomUUID)()}.tmp`;
-  await (0, import_promises44.writeFile)(staged, PLUGIN_MANIFEST, { mode: 384 });
-  await (0, import_promises44.rename)(staged, manifest);
+  await (0, import_promises45.writeFile)(staged, PLUGIN_MANIFEST, { mode: 384 });
+  await (0, import_promises45.rename)(staged, manifest);
 }
 async function reconcilePluginSkills(layout, installed, platform3) {
-  await (0, import_promises44.mkdir)(layout.pluginSkillsDir, { recursive: true, mode: 448 });
+  await (0, import_promises45.mkdir)(layout.pluginSkillsDir, { recursive: true, mode: 448 });
   const wanted = new Map(installed.map((skill) => [skill.slug, skill]));
   let linked = 0;
   for (const skill of installed) {
@@ -65700,16 +66153,16 @@ async function reconcilePluginSkills(layout, installed, platform3) {
       target: versionTarget(layout, skill.versionId, platform3)
     };
     if (await entryKind2(plan2.path) === "other") {
-      await (0, import_promises44.rm)(plan2.path, { recursive: true, force: true });
+      await (0, import_promises45.rm)(plan2.path, { recursive: true, force: true });
     }
     if (await placeLink(plan2, platform3)) linked += 1;
   }
   let unlinked = 0;
-  for (const name of await (0, import_promises44.readdir)(layout.pluginSkillsDir)) {
+  for (const name of await (0, import_promises45.readdir)(layout.pluginSkillsDir)) {
     if (wanted.has(name)) continue;
     const path4 = (0, import_node_path45.join)(layout.pluginSkillsDir, name);
     if (await entryKind2(path4) === "link") await removeLink(path4);
-    else await (0, import_promises44.rm)(path4, { recursive: true, force: true });
+    else await (0, import_promises45.rm)(path4, { recursive: true, force: true });
     unlinked += 1;
   }
   return { linked, unlinked };
@@ -65721,9 +66174,9 @@ async function isOwnCodexLink(layout, path4) {
   return isWithinDirectory2(layout.pluginSkillsDir, absolute);
 }
 async function isForeignPackage(layout, path4) {
-  const resolved = await (0, import_promises44.realpath)(path4).catch(() => null);
+  const resolved = await (0, import_promises45.realpath)(path4).catch(() => null);
   if (resolved === null) return false;
-  const root = await (0, import_promises44.realpath)(layout.root).catch(() => layout.root);
+  const root = await (0, import_promises45.realpath)(layout.root).catch(() => layout.root);
   return !isWithinDirectory2(root, resolved);
 }
 async function codexSlot(layout, path4, slug) {
@@ -65740,7 +66193,7 @@ async function codexSlot(layout, path4, slug) {
 }
 async function unlinkStaleCodexEntries(layout, codexSkillsDir, wanted) {
   let unlinked = 0;
-  for (const name of await (0, import_promises44.readdir)(codexSkillsDir)) {
+  for (const name of await (0, import_promises45.readdir)(codexSkillsDir)) {
     const path4 = (0, import_node_path45.join)(codexSkillsDir, name);
     if (wanted.has(name) && !name.endsWith(".tmp")) continue;
     if (await entryKind2(path4) !== "link" || !await isOwnCodexLink(layout, path4)) continue;
@@ -65750,7 +66203,7 @@ async function unlinkStaleCodexEntries(layout, codexSkillsDir, wanted) {
   return unlinked;
 }
 async function reconcileCodexSkills(layout, installed, codexSkillsDir, platform3) {
-  await (0, import_promises44.mkdir)(codexSkillsDir, { recursive: true, mode: 448 });
+  await (0, import_promises45.mkdir)(codexSkillsDir, { recursive: true, mode: 448 });
   const report2 = { linked: 0, unlinked: 0, skipped: [] };
   for (const skill of installed) {
     const path4 = (0, import_node_path45.join)(codexSkillsDir, skill.slug);
@@ -65787,35 +66240,35 @@ function installedSkillFolders(layout) {
 
 // src/capabilities/skills/sync.ts
 var import_node_crypto24 = require("crypto");
-var import_promises45 = require("fs/promises");
+var import_promises46 = require("fs/promises");
 var import_node_path46 = require("path");
 init_zod();
 var SKILL_PREPARE_WAIT_MS = 15e3;
 var RETIRED_VERSION_RETENTION_MS = 24 * 60 * 60 * 1e3;
 async function makeFilesReadOnly(directory, platform3) {
   if (platform3 === "win32") return;
-  for (const entry of await (0, import_promises45.readdir)(directory, { withFileTypes: true })) {
+  for (const entry of await (0, import_promises46.readdir)(directory, { withFileTypes: true })) {
     const path4 = (0, import_node_path46.join)(directory, entry.name);
     if (entry.isDirectory()) await makeFilesReadOnly(path4, platform3);
     else if (entry.isFile()) {
-      const executable = ((await (0, import_promises45.lstat)(path4)).mode & 64) !== 0;
-      await (0, import_promises45.chmod)(path4, executable ? 365 : 292);
+      const executable = ((await (0, import_promises46.lstat)(path4)).mode & 64) !== 0;
+      await (0, import_promises46.chmod)(path4, executable ? 365 : 292);
     }
   }
 }
 async function install(env, skill, download, signal) {
   const { layout, source, platform: platform3 } = env;
   const bytes = await source.download(download.url, signal);
-  await (0, import_promises45.mkdir)(layout.tmpDir, { recursive: true, mode: 448 });
+  await (0, import_promises46.mkdir)(layout.tmpDir, { recursive: true, mode: 448 });
   const staging = (0, import_node_path46.join)(layout.tmpDir, (0, import_node_crypto24.randomUUID)());
   await extractSkillBundle(Buffer.from(bytes), staging, {
     expectedArchiveHash: download.archiveHash,
     expectedContentHash: skill.contentHash
   });
   const target = packageDirectory(layout, skill.versionId);
-  await (0, import_promises45.mkdir)(layout.versionsDir, { recursive: true, mode: 448 });
-  await (0, import_promises45.rm)(target, { recursive: true, force: true });
-  await (0, import_promises45.rename)(staging, target);
+  await (0, import_promises46.mkdir)(layout.versionsDir, { recursive: true, mode: 448 });
+  await (0, import_promises46.rm)(target, { recursive: true, force: true });
+  await (0, import_promises46.rename)(staging, target);
   await makeFilesReadOnly(target, platform3);
 }
 var retiredFileSchema = external_exports.record(external_exports.string(), external_exports.number());
@@ -65827,14 +66280,14 @@ async function sweep(env, keep) {
   const now = env.now();
   const stillRetired = {};
   const expired = [];
-  for (const name of await (0, import_promises45.readdir)(layout.versionsDir).catch(() => [])) {
+  for (const name of await (0, import_promises46.readdir)(layout.versionsDir).catch(() => [])) {
     if (kept.has(name)) continue;
     const since = retired[name] ?? now;
     if (now - since >= RETIRED_VERSION_RETENTION_MS) expired.push(name);
     else stillRetired[name] = since;
   }
   const results = await Promise.allSettled(
-    expired.map((name) => (0, import_promises45.rm)((0, import_node_path46.join)(layout.versionsDir, name), { recursive: true, force: true }))
+    expired.map((name) => (0, import_promises46.rm)((0, import_node_path46.join)(layout.versionsDir, name), { recursive: true, force: true }))
   );
   results.forEach((result, index) => {
     const name = expired[index];
@@ -65843,7 +66296,7 @@ async function sweep(env, keep) {
   if (JSON.stringify(stillRetired) !== JSON.stringify(retired)) {
     await writeJsonFileAtomic(layout.retiredFile, stillRetired);
   }
-  await (0, import_promises45.rm)(layout.tmpDir, { recursive: true, force: true });
+  await (0, import_promises46.rm)(layout.tmpDir, { recursive: true, force: true });
   return results.filter((result) => result.status === "fulfilled").length;
 }
 async function intactSkills(layout) {
@@ -66171,7 +66624,7 @@ var import_node_path49 = require("path");
 init_runtime_v2();
 
 // src/capabilities/workspace/approved-paths.ts
-var import_promises46 = require("fs/promises");
+var import_promises47 = require("fs/promises");
 init_zod();
 
 // src/capabilities/workspace/paths.ts
@@ -66209,7 +66662,7 @@ var storeSchema = external_exports.object({
 });
 async function realpathOrNull(path4) {
   try {
-    return await (0, import_promises46.realpath)(path4);
+    return await (0, import_promises47.realpath)(path4);
   } catch (error61) {
     const code = errnoCode(error61);
     if (code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "EPERM") {
@@ -66269,7 +66722,7 @@ async function openApprovedPaths(options) {
 
 // src/capabilities/workspace/locks.ts
 var import_node_crypto25 = require("crypto");
-var import_promises47 = require("fs/promises");
+var import_promises48 = require("fs/promises");
 var import_node_path48 = require("path");
 init_zod();
 var LOCK_FORMAT = 1;
@@ -66290,7 +66743,7 @@ function repositoryLockKey(commonDir, platform3) {
 async function readOwner2(path4) {
   let text3;
   try {
-    text3 = await (0, import_promises47.readFile)(path4, "utf8");
+    text3 = await (0, import_promises48.readFile)(path4, "utf8");
   } catch (error61) {
     if (errnoCode(error61) === "ENOENT") return { kind: "missing" };
     return { kind: "unreadable" };
@@ -66311,7 +66764,7 @@ async function removeIfSame(path4, expected) {
     if (current.kind !== "owner" || current.owner.since !== expected.since) return;
     if (current.owner.pid !== expected.pid || current.owner.holder !== expected.holder) return;
   }
-  await (0, import_promises47.unlink)(path4).catch((error61) => {
+  await (0, import_promises48.unlink)(path4).catch((error61) => {
     if (errnoCode(error61) !== "ENOENT") throw error61;
   });
 }
@@ -66336,7 +66789,7 @@ function openRepositoryLocks(options) {
       await removeIfSame(path4, read.owner);
       return null;
     }
-    const age = await (0, import_promises47.stat)(path4).then(
+    const age = await (0, import_promises48.stat)(path4).then(
       (info) => clock.now() - info.mtimeMs,
       () => 0
     );
@@ -66351,12 +66804,12 @@ function openRepositoryLocks(options) {
   const folder = async (commonDir) => {
     const key = repositoryLockKey(commonDir, platform3);
     const dir = (0, import_node_path48.join)(options.dir, key);
-    await (0, import_promises47.mkdir)(dir, { recursive: true, mode: 448 });
+    await (0, import_promises48.mkdir)(dir, { recursive: true, mode: 448 });
     return { key, dir };
   };
   const createExclusive = async (path4, owner) => {
     try {
-      const handle = await (0, import_promises47.open)(path4, "wx", 384);
+      const handle = await (0, import_promises48.open)(path4, "wx", 384);
       try {
         await handle.writeFile(JSON.stringify(owner));
       } finally {
@@ -66369,7 +66822,7 @@ function openRepositoryLocks(options) {
     }
   };
   const liveRun = async (dir) => {
-    const entries = await (0, import_promises47.readdir)(dir);
+    const entries = await (0, import_promises48.readdir)(dir);
     for (const entry of entries) {
       if (!entry.startsWith(RUN_FILE_PREFIX)) continue;
       const holder = await heldBy((0, import_node_path48.join)(dir, entry));
@@ -66634,7 +67087,7 @@ async function openWorkspaces(options) {
 
 // src/cli/config.ts
 var import_node_os11 = require("os");
-var import_node_path69 = require("path");
+var import_node_path70 = require("path");
 init_zod();
 
 // src/client/contract.ts
@@ -66918,7 +67371,7 @@ var mcpConfigResultSchema = external_exports.object({
 });
 
 // src/client/runtime-client.ts
-var import_promises48 = require("fs/promises");
+var import_promises49 = require("fs/promises");
 init_acp();
 init_runtime_v2();
 
@@ -66979,7 +67432,7 @@ var DEFAULT_BACKOFF = { initialMs: 250, maxMs: 3e4 };
 async function readDiscovery(path4) {
   let text3;
   try {
-    text3 = await (0, import_promises48.readFile)(path4, "utf8");
+    text3 = await (0, import_promises49.readFile)(path4, "utf8");
   } catch (error61) {
     throw new RuntimeClientError("unavailable", "The runtime is not running", { cause: error61 });
   }
@@ -67362,9 +67815,9 @@ async function sendNativeHookSignal(discoveryPath, hookSignal, signal) {
 
 // src/sessions/index.ts
 var import_node_crypto31 = require("crypto");
-var import_promises67 = require("fs/promises");
+var import_promises69 = require("fs/promises");
 var import_node_os10 = require("os");
-var import_node_path68 = require("path");
+var import_node_path69 = require("path");
 init_runtime_v2();
 
 // src/holder/control-client.ts
@@ -67700,17 +68153,17 @@ function createConversationMcpAuthorization(options) {
 }
 
 // src/holder/mcp-helper-access.ts
-var import_promises55 = require("fs/promises");
+var import_promises56 = require("fs/promises");
 function createHelperMcpAccess(options) {
   return {
     [Symbol.asyncDispose]: async () => {
-      await (0, import_promises55.rm)(options.credentialPath, { force: true });
+      await (0, import_promises56.rm)(options.credentialPath, { force: true });
     },
     url: options.managedMcp.url,
     authorization: async (signal) => {
       const authorization = await options.managedMcp.authorization(signal);
       if (authorization === void 0 || signal.aborted) {
-        await (0, import_promises55.rm)(options.credentialPath, { force: true });
+        await (0, import_promises56.rm)(options.credentialPath, { force: true });
         return void 0;
       }
       const credential = {
@@ -67725,7 +68178,7 @@ function createHelperMcpAccess(options) {
 }
 
 // src/holder/run-inputs.ts
-var import_promises56 = require("fs/promises");
+var import_promises57 = require("fs/promises");
 var import_node_path54 = require("path");
 init_dist();
 var NO_RUN_INPUTS = {
@@ -67742,16 +68195,16 @@ function safeFilename(filename) {
 async function prepareRunInputs(spec, { source, tmpDir, signal, skills = [] }) {
   const dir = (0, import_node_path54.join)(tmpDir, "runs", spec.runId);
   const cleanup = async () => {
-    await (0, import_promises56.rm)(dir, { recursive: true, force: true });
+    await (0, import_promises57.rm)(dir, { recursive: true, force: true });
   };
   try {
     const credential = await source.fetchProviderCredential(spec.runId, signal);
     const attachments = [];
-    if (spec.attachments?.length) await (0, import_promises56.mkdir)(dir, { recursive: true, mode: 448 });
+    if (spec.attachments?.length) await (0, import_promises57.mkdir)(dir, { recursive: true, mode: 448 });
     for (const [index, attachment] of (spec.attachments ?? []).entries()) {
       const bytes = await source.downloadAttachment(spec.runId, attachment.id, signal);
       const path4 = (0, import_node_path54.join)(dir, `${index}-${safeFilename(attachment.filename)}`);
-      await (0, import_promises56.writeFile)(path4, bytes, { mode: 384 });
+      await (0, import_promises57.writeFile)(path4, bytes, { mode: 384 });
       const imageMimeType = attachment.kind === "image" ? detectImageMimeType(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)) : null;
       attachments.push({
         id: attachment.id,
@@ -67782,14 +68235,14 @@ async function prepareRunInputs(spec, { source, tmpDir, signal, skills = [] }) {
 var import_node_crypto30 = require("crypto");
 var import_node_fs22 = require("fs");
 var import_node_net3 = require("net");
-var import_node_path67 = require("path");
+var import_node_path68 = require("path");
 init_runtime_v2();
 
 // src/holder/admission.ts
 var import_node_fs19 = require("fs");
-var import_promises61 = require("fs/promises");
+var import_promises63 = require("fs/promises");
 var import_node_os9 = require("os");
-var import_node_path61 = require("path");
+var import_node_path62 = require("path");
 init_constants();
 
 // ../shared/dist/node/local-workspace.js
@@ -67801,7 +68254,7 @@ function resolveAlanDefaultWorkspacePath(homeDirectory = (0, import_node_os8.hom
 }
 
 // src/holder/admission-relocation.ts
-var import_promises57 = require("fs/promises");
+var import_promises58 = require("fs/promises");
 var import_node_path56 = require("path");
 var MAX_RELOCATION_CANDIDATES = 200;
 var RELOCATION_BUDGET_MS = 2e4;
@@ -67837,7 +68290,7 @@ async function originIdentity(git, path4, signal) {
 }
 async function childDirectories(parent, limit) {
   try {
-    const entries = await (0, import_promises57.readdir)(parent, { withFileTypes: true });
+    const entries = await (0, import_promises58.readdir)(parent, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).slice(0, limit).map((entry) => (0, import_node_path56.join)(parent, entry.name));
   } catch {
     return [];
@@ -67872,29 +68325,79 @@ async function discoverRelocatedWorkspace(search) {
   return matches[0] ?? null;
 }
 
+// src/holder/agent-context.ts
+var import_promises59 = require("fs/promises");
+var import_node_path57 = require("path");
+
+// ../agent-core/dist/prompt.js
+init_chunk_GI3ZGXTY();
+
+// src/holder/agent-context.ts
+async function readText4(path4) {
+  return (0, import_promises59.readFile)(path4, "utf8").then(
+    (text3) => text3.trim(),
+    () => null
+  );
+}
+async function startCommandState(statusPath) {
+  const [status, exit] = await Promise.all([readText4(statusPath), readText4(`${statusPath}.exit`)]);
+  if (status === null || status === "started") return { state: "pending" };
+  const failed = /^failed (\d+)$/.exec(status);
+  if (failed) return { state: "failed", exitCode: Number(failed[1]) };
+  if (exit === null) return { state: "running" };
+  const code = Number(exit);
+  return code === 0 ? { state: "exited_ok" } : { state: "failed", exitCode: code };
+}
+function createAgentContext(deps) {
+  const statusPath = (0, import_node_path57.join)(deps.homeDir, ".alan", "start-commands.status");
+  const logPath = (0, import_node_path57.join)(deps.homeDir, ".alan", "start-commands.log");
+  return async (spec, problems) => {
+    const file2 = (0, import_node_path57.join)(deps.dir, `${spec.conversationId}.json`);
+    const saved = await readJsonFile(file2, agentContextSnapshotSchema);
+    const known = saved.kind === "ok" ? saved.value : void 0;
+    const hasEnvironment = (spec.agentContext ?? known)?.environment !== void 0;
+    const start = hasEnvironment ? await startCommandState(statusPath) : void 0;
+    const snapshot2 = agentContextSnapshot({
+      spec,
+      ...spec.approvedWorkspacePaths?.[0] ? { workspaceRoot: spec.approvedWorkspacePaths[0] } : {},
+      problems,
+      ...start ? { start } : {},
+      startLogPath: logPath,
+      ...known ? { known } : {}
+    });
+    if (snapshot2 === null) return void 0;
+    const rendered = renderAgentContext(snapshot2, known);
+    return {
+      full: rendered.full,
+      ...rendered.update ? { update: rendered.update } : {},
+      save: () => writeJsonFileAtomic(file2, snapshot2)
+    };
+  };
+}
+
 // src/holder/checkout-refresh.ts
-var import_node_path59 = require("path");
+var import_node_path60 = require("path");
 
 // src/holder/claim-once.ts
 var import_node_crypto28 = require("crypto");
-var import_promises58 = require("fs/promises");
-var import_node_path57 = require("path");
+var import_promises60 = require("fs/promises");
+var import_node_path58 = require("path");
 async function claimOnce(dir, name) {
   try {
-    await (0, import_promises58.mkdir)(dir, { recursive: true, mode: 448 });
-    await (await (0, import_promises58.open)((0, import_node_path57.join)(dir, name), "wx")).close();
+    await (0, import_promises60.mkdir)(dir, { recursive: true, mode: 448 });
+    await (await (0, import_promises60.open)((0, import_node_path58.join)(dir, name), "wx")).close();
     return true;
   } catch {
     return false;
   }
 }
 function claimFirstLease(freshnessDir, path4) {
-  return claimOnce((0, import_node_path57.join)(freshnessDir, "leased"), (0, import_node_crypto28.createHash)("sha256").update(path4).digest("hex"));
+  return claimOnce((0, import_node_path58.join)(freshnessDir, "leased"), (0, import_node_crypto28.createHash)("sha256").update(path4).digest("hex"));
 }
 
 // src/holder/requested-checkout.ts
-var import_promises59 = require("fs/promises");
-var import_node_path58 = require("path");
+var import_promises61 = require("fs/promises");
+var import_node_path59 = require("path");
 var REMOTE2 = "origin";
 var REASON_MAX_CHARS = 200;
 function firstLine3(text3) {
@@ -67903,24 +68406,20 @@ function firstLine3(text3) {
 function reasonOf(output2, command) {
   return firstLine3(output2.stderr) || `git ${command} exited ${output2.exitCode}`;
 }
-function noted(checkout, situation, reason, action) {
-  return {
-    kind: "noted",
-    line: `Note: ${checkout.path} ${situation}: ${reason}. ${action} before relying on its files.`
-  };
+function noted(situation, reason, action) {
+  return { kind: "noted", problem: `${situation}: ${reason}`, action };
 }
 function notSwitched(checkout, current, reason) {
   const on2 = current ?? "a detached HEAD";
   return noted(
-    checkout,
     `is on ${on2}, not ${checkout.branch}, the branch picked for this chat`,
     reason,
     `Switch it to ${checkout.branch}`
   );
 }
 async function clone2(checkout, deps, signal) {
-  const parent = (0, import_node_path58.dirname)(checkout.path);
-  await (0, import_promises59.mkdir)(parent, { recursive: true });
+  const parent = (0, import_node_path59.dirname)(checkout.path);
+  await (0, import_promises61.mkdir)(parent, { recursive: true });
   await assertValidBranch(deps.git, parent, checkout.branch, signal);
   const output2 = await deps.git.run(
     {
@@ -67942,7 +68441,6 @@ async function clone2(checkout, deps, signal) {
   );
   if (output2.exitCode === 0) return { kind: "moved", how: "cloned" };
   return noted(
-    checkout,
     `is missing, and cloning it on ${checkout.branch}, the branch picked for this chat, failed`,
     reasonOf(output2, "clone"),
     `Clone ${checkout.repoUrl} there`
@@ -68004,7 +68502,6 @@ async function moveOnto(checkout, git, tip, current) {
   if (localHead === tip) return SWITCHED;
   const merged = await git(["merge", "--quiet", "--ff-only", tip]);
   return merged.exitCode === 0 ? SWITCHED : noted(
-    checkout,
     `is on ${branch} but behind ${REMOTE2}/${branch}`,
     reasonOf(merged, "merge"),
     "Run `git pull --ff-only` there"
@@ -68063,7 +68560,6 @@ async function applyRequestedCheckout(checkout, spec, deps, signal) {
     return await switchTo(checkout, status.branch, `checkout-${spec.runId}`, deps, signal);
   } catch (error61) {
     return noted(
-      checkout,
       `could not be put on ${checkout.branch}, the branch picked for this chat`,
       firstLine3(error61 instanceof Error ? error61.message : String(error61)) || "unknown error",
       "Check it"
@@ -68075,11 +68571,15 @@ async function applyRequestedCheckout(checkout, spec, deps, signal) {
 function short(sha) {
   return sha.slice(0, 12);
 }
-function staleLine(path4, snapshot2, tip) {
+function staleCheckout(path4, snapshot2, tip) {
   const checkout = snapshot2 === void 0 ? "is the environment snapshot's checkout" : `is the environment snapshot's checkout of ${snapshot2.branch} (commit ${short(snapshot2.head)})`;
   const base = snapshot2 === void 0 ? "its upstream" : `origin/${snapshot2.base}`;
   const remote = tip === void 0 ? "may be ahead" : `is ahead at ${short(tip)}`;
-  return `Note: ${path4} ${checkout}; ${base} ${remote}. Run \`git pull --ff-only\` there before relying on its files.`;
+  return {
+    path: path4,
+    problem: `${checkout}; ${base} ${remote}`,
+    action: "Run `git pull --ff-only` there"
+  };
 }
 async function fastForward(freshness, operationId, deps, signal) {
   var _stack = [];
@@ -68117,14 +68617,14 @@ async function atFirstLease(freshness, spec, deps, signal) {
       return first && freshness.fetched && await fastForward(freshness, `refresh-${spec.runId}`, deps, signal) ? "moved" : "noted";
   }
 }
-function lineFor(freshness) {
+function problemFor(freshness) {
   switch (freshness.state) {
     case "behind":
-      return staleLine(freshness.path, freshness.snapshot, freshness.tip);
+      return staleCheckout(freshness.path, freshness.snapshot, freshness.tip);
     case "failed":
-      return staleLine(freshness.path, freshness.snapshot);
+      return staleCheckout(freshness.path, freshness.snapshot);
     default:
-      return staleLine(freshness.path, void 0);
+      return staleCheckout(freshness.path, void 0);
   }
 }
 async function checkoutsOf(spec, leaseTargets) {
@@ -68146,7 +68646,7 @@ function requestedCheckoutsOf(spec, log) {
 }
 async function applyRequestedCheckouts(spec, deps, signal) {
   const settled2 = /* @__PURE__ */ new Set();
-  const lines2 = [];
+  const problems = [];
   for (const checkout of requestedCheckoutsOf(spec, deps.log)) {
     const outcome2 = await applyRequestedCheckout(checkout, spec, deps, signal);
     deps.log.info("workspace.requested_checkout", {
@@ -68157,21 +68657,23 @@ async function applyRequestedCheckouts(spec, deps, signal) {
       ...outcome2.kind === "moved" ? { how: outcome2.how } : {}
     });
     if (outcome2.kind === "on_branch") continue;
-    settled2.add((0, import_node_path59.resolve)(checkout.path));
-    if (outcome2.kind === "noted") lines2.push(outcome2.line);
+    settled2.add((0, import_node_path60.resolve)(checkout.path));
+    if (outcome2.kind === "noted") {
+      problems.push({ path: checkout.path, problem: outcome2.problem, action: outcome2.action });
+    }
   }
-  return { settled: settled2, lines: lines2 };
+  return { settled: settled2, problems };
 }
 async function refreshSnapshotCheckouts(spec, targets, settled2, deps, signal) {
-  const lines2 = [];
+  const problems = [];
   for (const target of targets) {
-    if (settled2.has((0, import_node_path59.resolve)(target))) continue;
+    if (settled2.has((0, import_node_path60.resolve)(target))) continue;
     const freshness = await readCheckoutFreshness(deps.dir, target);
     if (freshness === null) continue;
     const outcome2 = await atFirstLease(freshness, spec, deps, signal).catch(
       () => "noted"
     );
-    if (outcome2 === "noted") lines2.push(lineFor(freshness));
+    if (outcome2 === "noted") problems.push(problemFor(freshness));
     deps.log.info("workspace.refresh", {
       runId: spec.runId,
       path: freshness.path,
@@ -68179,25 +68681,24 @@ async function refreshSnapshotCheckouts(spec, targets, settled2, deps, signal) {
       outcome: outcome2
     });
   }
-  return lines2;
+  return problems;
 }
 function createCheckoutRefresh(deps) {
   return async (spec, leaseTargets, signal) => {
-    if (spec.providerSessionId !== void 0) return void 0;
-    if (!await claimOnce((0, import_node_path59.join)(deps.dir, "conversations"), spec.conversationId)) return void 0;
+    if (spec.providerSessionId !== void 0) return [];
+    if (!await claimOnce((0, import_node_path60.join)(deps.dir, "conversations"), spec.conversationId)) return [];
     const requested = await applyRequestedCheckouts(spec, deps, signal);
     const targets = await checkoutsOf(spec, leaseTargets);
-    const lines2 = [
-      ...requested.lines,
+    return [
+      ...requested.problems,
       ...await refreshSnapshotCheckouts(spec, targets, requested.settled, deps, signal)
     ];
-    return lines2.length === 0 ? void 0 : lines2.join("\n");
   };
 }
 
 // src/holder/lease.ts
-var import_promises60 = require("fs/promises");
-var import_node_path60 = require("path");
+var import_promises62 = require("fs/promises");
+var import_node_path61 = require("path");
 var LEASE_CHECK_EVERY_MS = 5e3;
 var MAX_TRANSIENT_FAILURES = 3;
 var BACKOFF_BASE_MS = 1e3;
@@ -68211,8 +68712,8 @@ function identityFailure(code, workspacePath) {
   return { code, problemCode: "app.workspace.missing", message: MESSAGES[code], workspacePath };
 }
 async function fileIdentity(path4) {
-  const canonical = await (0, import_promises60.realpath)(path4);
-  const info = await (0, import_promises60.stat)(canonical, { bigint: true });
+  const canonical = await (0, import_promises62.realpath)(path4);
+  const info = await (0, import_promises62.stat)(canonical, { bigint: true });
   return `${canonical}:${info.dev}:${info.ino}`;
 }
 async function snapshot(git, path4, signal) {
@@ -68231,7 +68732,7 @@ async function snapshot(git, path4, signal) {
       workspace: await fileIdentity(path4),
       repository: await fileIdentity(commonDir),
       worktree: await fileIdentity(gitDir),
-      commonDir: await (0, import_promises60.realpath)(commonDir)
+      commonDir: await (0, import_promises62.realpath)(commonDir)
     };
   } catch {
     return null;
@@ -68244,7 +68745,7 @@ async function gitValue(git, path4, args, signal) {
 }
 async function pathExists(path4) {
   try {
-    await (0, import_promises60.stat)(path4);
+    await (0, import_promises62.stat)(path4);
     return true;
   } catch (error61) {
     return errnoCode(error61) !== "ENOENT" && errnoCode(error61) !== "ENOTDIR";
@@ -68253,19 +68754,19 @@ async function pathExists(path4) {
 async function hasGitMarker(path4) {
   let directory;
   try {
-    directory = await (0, import_promises60.realpath)(path4);
+    directory = await (0, import_promises62.realpath)(path4);
   } catch {
     return true;
   }
   for (; ; ) {
     try {
-      await (0, import_promises60.stat)((0, import_node_path60.join)(directory, ".git"));
+      await (0, import_promises62.stat)((0, import_node_path61.join)(directory, ".git"));
       return true;
     } catch (error61) {
       const code = errnoCode(error61);
       if (code !== "ENOENT" && code !== "ENOTDIR") return true;
     }
-    const parent = (0, import_node_path60.dirname)(directory);
+    const parent = (0, import_node_path61.dirname)(directory);
     if (parent === directory) return false;
     directory = parent;
   }
@@ -68429,7 +68930,7 @@ function volumeRoot(path4) {
 }
 async function exists4(path4) {
   try {
-    await (0, import_promises61.stat)(path4);
+    await (0, import_promises63.stat)(path4);
     return true;
   } catch {
     return false;
@@ -68437,10 +68938,10 @@ async function exists4(path4) {
 }
 async function inspectReadiness(path4) {
   try {
-    if (!(await (0, import_promises61.stat)(path4)).isDirectory()) {
+    if (!(await (0, import_promises63.stat)(path4)).isDirectory()) {
       return { ready: false, missing: true, message: MESSAGES2.missing };
     }
-    await (0, import_promises61.access)(path4, import_node_fs19.constants.R_OK | import_node_fs19.constants.W_OK | import_node_fs19.constants.X_OK);
+    await (0, import_promises63.access)(path4, import_node_fs19.constants.R_OK | import_node_fs19.constants.W_OK | import_node_fs19.constants.X_OK);
     return { ready: true };
   } catch (error61) {
     const code = errnoCode(error61) ?? "";
@@ -68518,8 +69019,8 @@ async function admitDefaultWorkspace(spec, context, skills) {
   const { env } = context;
   const path4 = resolveAlanDefaultWorkspacePath(env.HOME || env.USERPROFILE || (0, import_node_os9.homedir)());
   try {
-    await (0, import_promises61.mkdir)(path4, { recursive: true, mode: 448 });
-    await (0, import_promises61.access)(path4, import_node_fs19.constants.R_OK | import_node_fs19.constants.W_OK | import_node_fs19.constants.X_OK);
+    await (0, import_promises63.mkdir)(path4, { recursive: true, mode: 448 });
+    await (0, import_promises63.access)(path4, import_node_fs19.constants.R_OK | import_node_fs19.constants.W_OK | import_node_fs19.constants.X_OK);
     return {
       kind: "admitted",
       spec: { ...spec, projectPath: path4 },
@@ -68597,7 +69098,7 @@ var CHECKOUT_NETWORK_TIMEOUT_MS = 12e4;
 function createHolderWorkspace(machine, clock, log) {
   const platform3 = machine.platform ?? process.platform;
   const git = createGitRunner({ env: machine.env, platform: platform3, localTimeoutMs: PROBE_TIMEOUT_MS2 });
-  const locks = openRepositoryLocks({ dir: (0, import_node_path61.join)(machine.stateDir, "locks"), clock, platform: platform3 });
+  const locks = openRepositoryLocks({ dir: (0, import_node_path62.join)(machine.stateDir, "locks"), clock, platform: platform3 });
   return {
     admission: {
       env: machine.env,
@@ -68609,7 +69110,7 @@ function createHolderWorkspace(machine, clock, log) {
       ),
       approvedRoots: async () => {
         const approved = await openApprovedPaths({
-          file: (0, import_node_path61.join)(machine.stateDir, "workspaces.json"),
+          file: (0, import_node_path62.join)(machine.stateDir, "workspaces.json"),
           log,
           platform: platform3
         });
@@ -68627,7 +69128,11 @@ function createHolderWorkspace(machine, clock, log) {
         }),
         locks,
         log,
-        dir: (0, import_node_path61.join)(machine.stateDir, "checkout-freshness")
+        dir: (0, import_node_path62.join)(machine.stateDir, "checkout-freshness")
+      }),
+      prepareAgentContext: createAgentContext({
+        dir: (0, import_node_path62.join)(machine.stateDir, "agent-context"),
+        homeDir: machine.env.HOME || (0, import_node_os9.homedir)()
       })
     } : {}
   };
@@ -68655,7 +69160,7 @@ async function respondToTurn(runningRunId, gate, driver, request2) {
 }
 
 // src/holder/session-facts.ts
-var import_promises62 = require("fs/promises");
+var import_promises64 = require("fs/promises");
 var CLI_RSS_CACHE_MS = 1e4;
 var LOGIN_PROBLEM_PREFIX = "cli.auth.";
 function isLoginFailure(result) {
@@ -68681,8 +69186,8 @@ function createSessionFacts(options) {
     const path4 = await resolveCommandOnPath(command, env, platform3);
     if (path4 === null) return null;
     try {
-      const real = await (0, import_promises62.realpath)(path4);
-      const info = await (0, import_promises62.stat)(real);
+      const real = await (0, import_promises64.realpath)(path4);
+      const info = await (0, import_promises64.stat)(real);
       return { command, key: `${real}:${info.ino}:${info.size}:${info.mtimeMs}` };
     } catch {
       return null;
@@ -68769,12 +69274,12 @@ function createSessionFacts(options) {
 init_acp2();
 
 // src/run-log/archive.ts
-var import_promises63 = require("fs/promises");
-var import_node_path62 = require("path");
+var import_promises65 = require("fs/promises");
+var import_node_path63 = require("path");
 init_runtime_v2();
 async function openRunArchive(runsDir) {
-  const path4 = (0, import_node_path62.join)((0, import_node_path62.dirname)(runsDir), "archived-runs.txt");
-  const text3 = await (0, import_promises63.readFile)(path4, "utf8").catch((error61) => {
+  const path4 = (0, import_node_path63.join)((0, import_node_path63.dirname)(runsDir), "archived-runs.txt");
+  const text3 = await (0, import_promises65.readFile)(path4, "utf8").catch((error61) => {
     if (errnoCode(error61) === "ENOENT") return "";
     throw error61;
   });
@@ -68788,7 +69293,7 @@ async function openRunArchive(runsDir) {
     add: async (runIds) => {
       const added = runIds.filter((runId) => !archived.has(runId));
       if (added.length === 0) return;
-      await (0, import_promises63.appendFile)(path4, `
+      await (0, import_promises65.appendFile)(path4, `
 ${added.join("\n")}
 `, { mode: 384 });
       for (const runId of added) archived.add(runId);
@@ -68799,11 +69304,11 @@ ${added.join("\n")}
 // src/run-log/complete.ts
 var import_node_crypto29 = require("crypto");
 var import_node_fs20 = require("fs");
-var import_node_path64 = require("path");
+var import_node_path65 = require("path");
 
 // src/run-log/directory.ts
-var import_promises64 = require("fs/promises");
-var import_node_path63 = require("path");
+var import_promises66 = require("fs/promises");
+var import_node_path64 = require("path");
 init_runtime_v2();
 init_zod();
 var runMetaSchema = external_exports.object({
@@ -68829,17 +69334,17 @@ async function readRunMeta(path4) {
   return read.kind === "ok" ? read.value : null;
 }
 function runDirectory(runsDir, runId) {
-  const dir = (0, import_node_path63.join)(runsDir, runId);
+  const dir = (0, import_node_path64.join)(runsDir, runId);
   return {
     dir,
-    log: (0, import_node_path63.join)(dir, "log.jsonl"),
-    upload: (0, import_node_path63.join)(dir, "upload.json"),
-    meta: (0, import_node_path63.join)(dir, "run.json")
+    log: (0, import_node_path64.join)(dir, "log.jsonl"),
+    upload: (0, import_node_path64.join)(dir, "upload.json"),
+    meta: (0, import_node_path64.join)(dir, "run.json")
   };
 }
 async function isRunClaimed(runsDir, runId) {
   try {
-    return (await (0, import_promises64.stat)(runDirectory(runsDir, runId).log)).size > 0;
+    return (await (0, import_promises66.stat)(runDirectory(runsDir, runId).log)).size > 0;
   } catch (error61) {
     if (errnoCode(error61) === "ENOENT") return false;
     throw error61;
@@ -68848,7 +69353,7 @@ async function isRunClaimed(runsDir, runId) {
 
 // src/run-log/complete.ts
 function writeLogFile(path4, dir, text3) {
-  const temp = (0, import_node_path64.join)(dir, `.log.${(0, import_node_crypto29.randomUUID)()}.tmp`);
+  const temp = (0, import_node_path65.join)(dir, `.log.${(0, import_node_crypto29.randomUUID)()}.tmp`);
   const fd = (0, import_node_fs20.openSync)(temp, "wx", 384);
   try {
     (0, import_node_fs20.writeSync)(fd, text3);
@@ -68877,8 +69382,8 @@ async function writeCompleteRunLog(runsDir, meta3, records) {
 }
 
 // src/run-log/conversation-index.ts
-var import_promises65 = require("fs/promises");
-var import_node_path65 = require("path");
+var import_promises67 = require("fs/promises");
+var import_node_path66 = require("path");
 init_runtime_v2();
 init_zod();
 var ORDINALS_PER_SHARD = 1e3;
@@ -68895,13 +69400,13 @@ var coverageSchema = external_exports.object({
   nextExpectedOrdinal: external_exports.number().int().positive()
 });
 function conversationsDirectory(runsDir) {
-  return (0, import_node_path65.join)((0, import_node_path65.dirname)(runsDir), "conversations");
+  return (0, import_node_path66.join)((0, import_node_path66.dirname)(runsDir), "conversations");
 }
 function indexDirectory(runsDir, conversationId) {
-  return (0, import_node_path65.join)(conversationsDirectory(runsDir), conversationId, "turn-index");
+  return (0, import_node_path66.join)(conversationsDirectory(runsDir), conversationId, "turn-index");
 }
 function shardPath(runsDir, conversationId, ordinal) {
-  return (0, import_node_path65.join)(
+  return (0, import_node_path66.join)(
     indexDirectory(runsDir, conversationId),
     `${Math.floor(ordinal / ORDINALS_PER_SHARD)}.jsonl`
   );
@@ -68910,10 +69415,10 @@ async function indexConversationRun(runsDir, conversationId, ordinal, assistantO
   const nextOrdinal = assistantOrdinal + 1;
   if (nextOrdinal <= ordinal) throw new Error("Assistant order must follow the prompt");
   const path4 = shardPath(runsDir, conversationId, ordinal);
-  await (0, import_promises65.mkdir)((0, import_node_path65.dirname)(path4), { recursive: true, mode: 448 });
-  await (0, import_promises65.appendFile)(path4, `${JSON.stringify({ ordinal, nextOrdinal, runId })}
+  await (0, import_promises67.mkdir)((0, import_node_path66.dirname)(path4), { recursive: true, mode: 448 });
+  await (0, import_promises67.appendFile)(path4, `${JSON.stringify({ ordinal, nextOrdinal, runId })}
 `, { mode: 384 });
-  const coveragePath = (0, import_node_path65.join)((0, import_node_path65.dirname)((0, import_node_path65.dirname)(path4)), "coverage.json");
+  const coveragePath = (0, import_node_path66.join)((0, import_node_path66.dirname)((0, import_node_path66.dirname)(path4)), "coverage.json");
   const coverage = await readJsonFile(coveragePath, coverageSchema);
   const current = coverage.kind === "ok" ? coverage.value : null;
   const next = nextCoverage(current, ordinal, nextOrdinal);
@@ -68928,13 +69433,13 @@ function nextCoverage(current, ordinal, nextOrdinal) {
   return null;
 }
 async function readConversationIndexCoverage(runsDir, conversationId) {
-  const path4 = (0, import_node_path65.join)((0, import_node_path65.dirname)(indexDirectory(runsDir, conversationId)), "coverage.json");
+  const path4 = (0, import_node_path66.join)((0, import_node_path66.dirname)(indexDirectory(runsDir, conversationId)), "coverage.json");
   const result = await readJsonFile(path4, coverageSchema);
   return result.kind === "ok" ? result.value : null;
 }
 async function readConversationRunIndex(runsDir, conversationId, before, limit) {
   const directory = indexDirectory(runsDir, conversationId);
-  const names = await (0, import_promises65.readdir)(directory).catch((error61) => {
+  const names = await (0, import_promises67.readdir)(directory).catch((error61) => {
     if (error61.code === "ENOENT") return [];
     throw error61;
   });
@@ -68943,7 +69448,7 @@ async function readConversationRunIndex(runsDir, conversationId, before, limit)
   ).sort((left, right) => right - left);
   const selected = [];
   for (const shard of shards) {
-    const text3 = await (0, import_promises65.readFile)((0, import_node_path65.join)(directory, `${shard}.jsonl`), "utf8");
+    const text3 = await (0, import_promises67.readFile)((0, import_node_path66.join)(directory, `${shard}.jsonl`), "utf8");
     const records = text3.split("\n").flatMap((line) => {
       if (!line) return [];
       const parsed = indexRecordSchema.parse(JSON.parse(line));
@@ -68968,7 +69473,7 @@ async function readIndexableRun(runsDir, name) {
   return { conversationId: meta3.conversationId, ordinal, assistantOrdinal, runId: runId.data };
 }
 async function readIndexableRuns(runsDir) {
-  const names = await (0, import_promises65.readdir)(runsDir).catch(() => []);
+  const names = await (0, import_promises67.readdir)(runsDir).catch(() => []);
   const byConversation = /* @__PURE__ */ new Map();
   let next = 0;
   const worker = async () => {
@@ -68998,21 +69503,21 @@ async function writeConversationIndex(directory, runs) {
     else lines2.push(line);
     coverage = nextCoverage(coverage, run2.ordinal, nextOrdinal) ?? coverage;
   }
-  await (0, import_promises65.mkdir)((0, import_node_path65.join)(directory, "turn-index"), { recursive: true, mode: 448 });
+  await (0, import_promises67.mkdir)((0, import_node_path66.join)(directory, "turn-index"), { recursive: true, mode: 448 });
   for (const [shard, lines2] of shards) {
-    await (0, import_promises65.writeFile)((0, import_node_path65.join)(directory, "turn-index", `${shard}.jsonl`), `${lines2.join("\n")}
+    await (0, import_promises67.writeFile)((0, import_node_path66.join)(directory, "turn-index", `${shard}.jsonl`), `${lines2.join("\n")}
 `, {
       mode: 384
     });
   }
-  await (0, import_promises65.writeFile)((0, import_node_path65.join)(directory, "coverage.json"), `${JSON.stringify(coverage)}
+  await (0, import_promises67.writeFile)((0, import_node_path66.join)(directory, "coverage.json"), `${JSON.stringify(coverage)}
 `, {
     mode: 384
   });
 }
 async function rebuildConversationIndexes(runsDir) {
   const root = conversationsDirectory(runsDir);
-  const exists6 = await (0, import_promises65.stat)(root).then(
+  const exists6 = await (0, import_promises67.stat)(root).then(
     () => true,
     (error61) => {
       if (errnoCode(error61) === "ENOENT") return false;
@@ -69021,18 +69526,18 @@ async function rebuildConversationIndexes(runsDir) {
   );
   if (exists6) return 0;
   const building = `${root}.rebuilding`;
-  await (0, import_promises65.rm)(building, { recursive: true, force: true });
-  await (0, import_promises65.mkdir)(building, { recursive: true, mode: 448 });
+  await (0, import_promises67.rm)(building, { recursive: true, force: true });
+  await (0, import_promises67.mkdir)(building, { recursive: true, mode: 448 });
   const byConversation = await readIndexableRuns(runsDir);
   for (const [conversationId, runs] of byConversation) {
-    await writeConversationIndex((0, import_node_path65.join)(building, conversationId), runs);
+    await writeConversationIndex((0, import_node_path66.join)(building, conversationId), runs);
   }
-  await (0, import_promises65.rename)(building, root);
+  await (0, import_promises67.rename)(building, root);
   return byConversation.size;
 }
 
 // src/run-log/reader.ts
-var import_promises66 = require("fs/promises");
+var import_promises68 = require("fs/promises");
 init_runtime_v2();
 
 // src/run-log/tail.ts
@@ -69055,7 +69560,7 @@ function firstRecordLength(bytes) {
   return bytes.indexOf(RUN_LOG_RECORD_SEPARATOR) + 1;
 }
 async function openRunLogReader(path4) {
-  const handle = await (0, import_promises66.open)(path4, "r");
+  const handle = await (0, import_promises68.open)(path4, "r");
   const readAt = async (position, length) => {
     const buffer = Buffer.alloc(length);
     const { bytesRead } = await handle.read(buffer, 0, length, position);
@@ -69089,7 +69594,7 @@ async function openRunLogReader(path4) {
   };
 }
 async function readLastRecord(path4) {
-  const handle = await (0, import_promises66.open)(path4, "r").catch(() => null);
+  const handle = await (0, import_promises68.open)(path4, "r").catch(() => null);
   if (handle === null) return null;
   try {
     const { size } = await handle.stat();
@@ -69123,7 +69628,7 @@ var decoder = new TextDecoder();
 
 // src/run-log/writer.ts
 var import_node_fs21 = require("fs");
-var import_node_path66 = require("path");
+var import_node_path67 = require("path");
 init_runtime_v2();
 function lastSeq(fd, size) {
   for (const length of tailWindows(size)) {
@@ -69139,7 +69644,7 @@ function lastSeq(fd, size) {
   throw new RuntimeFault("record_too_large", "Run log tail record is larger than any record");
 }
 function openRunLog(path4, clock) {
-  (0, import_node_fs21.mkdirSync)((0, import_node_path66.dirname)(path4), { recursive: true, mode: 448 });
+  (0, import_node_fs21.mkdirSync)((0, import_node_path67.dirname)(path4), { recursive: true, mode: 448 });
   const fd = (0, import_node_fs21.openSync)(path4, "a+", 384);
   let size = (0, import_node_fs21.fstatSync)(fd).size;
   let seq = lastSeq(fd, size);
@@ -69317,8 +69822,12 @@ function fitForRunLog(update) {
 async function runWithInputs({ spec, leaseTargets, skills }, context, sink, signal) {
   var _stack = [];
   try {
-    const refreshed = context.workspace?.refreshFirstCheckout?.(spec, leaseTargets, signal).catch((error61) => {
+    const workspace = context.workspace;
+    const sessionContext = (workspace?.refreshFirstCheckout?.(spec, leaseTargets, signal) ?? Promise.resolve([])).catch((error61) => {
       context.log.warn("workspace.refresh_failed", { runId: spec.runId, error: error61 });
+      return [];
+    }).then((problems) => workspace?.prepareAgentContext?.(spec, problems)).catch((error61) => {
+      context.log.warn("holder.agent_context_failed", { runId: spec.runId, error: error61 });
       return void 0;
     });
     let inputs;
@@ -69331,17 +69840,37 @@ async function runWithInputs({ spec, leaseTargets, skills }, context, sink, sign
         message: `Could not fetch this run's attachments or provider credential: ${error61 instanceof Error ? error61.message : String(error61)}`
       };
     }
-    const turnContext = await refreshed;
+    const agentContext = await sessionContext;
     const prepared = __using(_stack, inputs, true);
-    const run2 = (turnSink, turnSignal) => context.driver.runTurn(
+    const run2 = async (turnSink, turnSignal) => {
+      const result = await context.driver.runTurn(
+        spec,
+        turnSink,
+        turnSignal,
+        agentContext === void 0 ? prepared : {
+          ...prepared,
+          agentContext: {
+            full: agentContext.full,
+            ...agentContext.update ? { update: agentContext.update } : {}
+          }
+        }
+      );
+      if (agentContext !== void 0 && result.outcome !== "rejected") {
+        await agentContext.save().catch((error61) => {
+          context.log.warn("holder.agent_context_save_failed", { runId: spec.runId, error: error61 });
+        });
+      }
+      return result;
+    };
+    if (workspace === void 0) return await run2(sink, signal);
+    return await runLeased(
       spec,
-      turnSink,
-      turnSignal,
-      turnContext === void 0 ? prepared : { ...prepared, turnContext }
+      leaseTargets,
+      { ...context, lease: workspace.lease },
+      sink,
+      signal,
+      run2
     );
-    if (context.workspace === void 0) return await run2(sink, signal);
-    const leased = { ...context, lease: context.workspace.lease };
-    return await runLeased(spec, leaseTargets, leased, sink, signal, run2);
   } catch (_) {
     var _error = _, _hasError = true;
   } finally {
@@ -69475,7 +70004,7 @@ async function runHolder({
   try {
     const identity = await readProcessIdentity(process.pid);
     if (identity === null) throw new RuntimeFault("internal", "Cannot read own process identity");
-    const _engines = __using(_stack, recordSpawnedEngines(engineRecordsPath((0, import_node_path67.dirname)(launch.statusPath)), clock, log));
+    const _engines = __using(_stack, recordSpawnedEngines(engineRecordsPath((0, import_node_path68.dirname)(launch.statusPath)), clock, log));
     const holder = {
       state: "idle",
       runId: null,
@@ -69769,7 +70298,7 @@ var DEFAULT_MAX_ACTIVE_RUNS = 32;
 var HOLDER_BUSY = "busy";
 async function listIds(dir, schema) {
   const ids = [];
-  for (const name of await (0, import_promises67.readdir)(dir).catch(() => [])) {
+  for (const name of await (0, import_promises69.readdir)(dir).catch(() => [])) {
     const parsed = schema.safeParse(name);
     if (parsed.success) ids.push(parsed.data);
   }
@@ -69783,14 +70312,14 @@ function holderIdentity(status) {
   return command === void 0 ? { pid, startedAt } : { pid, startedAt, command };
 }
 function sessionFiles(paths, conversationId) {
-  const dir = (0, import_node_path68.join)(paths.sessions, conversationId);
-  return { dir, launch: (0, import_node_path68.join)(dir, "launch.json"), status: (0, import_node_path68.join)(dir, "holder.json") };
+  const dir = (0, import_node_path69.join)(paths.sessions, conversationId);
+  return { dir, launch: (0, import_node_path69.join)(dir, "launch.json"), status: (0, import_node_path69.join)(dir, "holder.json") };
 }
 async function removeHolderFiles(files) {
   for (const path4 of [files.launch, files.status, engineRecordsPath(files.dir)]) {
-    await (0, import_promises67.rm)(path4, { force: true });
+    await (0, import_promises69.rm)(path4, { force: true });
   }
-  await (0, import_promises67.rmdir)(files.dir).catch((error61) => {
+  await (0, import_promises69.rmdir)(files.dir).catch((error61) => {
     if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(errnoCode(error61) ?? "")) throw error61;
   });
 }
@@ -69980,7 +70509,7 @@ async function openSessions(deps) {
     const meta3 = await readRunMeta(dir.meta);
     const last = await readLastRecord(dir.log);
     if (meta3 === null || last === null) return null;
-    const logged = await (0, import_promises67.stat)(dir.log).catch((error61) => {
+    const logged = await (0, import_promises69.stat)(dir.log).catch((error61) => {
       if (errnoCode(error61) === "ENOENT") return null;
       throw error61;
     });
@@ -70292,7 +70821,7 @@ function loadRuntimeConfig(env = process.env, totalMemoryBytes = (0, import_node
     providerProbes: ALAN_RUNTIME_PROVIDER_PROBES === "on",
     providerToolchain: ALAN_RUNTIME_PROVIDER_NODE !== void 0 && ALAN_RUNTIME_PROVIDER_NPM_CLI !== void 0 ? { node: ALAN_RUNTIME_PROVIDER_NODE, npmCli: ALAN_RUNTIME_PROVIDER_NPM_CLI } : null,
     home,
-    configHome: XDG_CONFIG_HOME ?? (0, import_node_path69.join)(home, ".config"),
+    configHome: XDG_CONFIG_HOME ?? (0, import_node_path70.join)(home, ".config"),
     codexHome: resolveCodexHome(CODEX_HOME, home),
     ...githubProxyConfig({ ALAN_RUNTIME_GITHUB_PROXY, XDG_CONFIG_HOME, GH_CONFIG_DIR }, home),
     gitGatewayUrl: ALAN_RUNTIME_GIT_GATEWAY_URL ?? null,
@@ -70302,13 +70831,13 @@ function loadRuntimeConfig(env = process.env, totalMemoryBytes = (0, import_node
   };
 }
 function resolveCodexHome(configuredHome, home) {
-  return configuredHome ?? (0, import_node_path69.join)(home, ".codex");
+  return configuredHome ?? (0, import_node_path70.join)(home, ".codex");
 }
 function githubProxyConfig(env, home) {
-  const configHome = env.XDG_CONFIG_HOME ?? (0, import_node_path69.join)(home, ".config");
+  const configHome = env.XDG_CONFIG_HOME ?? (0, import_node_path70.join)(home, ".config");
   return {
     githubProxy: env.ALAN_RUNTIME_GITHUB_PROXY === "on",
-    ghConfigDir: env.GH_CONFIG_DIR ?? (0, import_node_path69.join)(configHome, "gh")
+    ghConfigDir: env.GH_CONFIG_DIR ?? (0, import_node_path70.join)(configHome, "gh")
   };
 }
 function serviceEnvironment2(env, profile) {
@@ -70366,9 +70895,9 @@ function takeEnrollmentCodeFromEnv(env = process.env) {
 }
 
 // src/cli/context.ts
-var import_promises68 = require("fs/promises");
+var import_promises70 = require("fs/promises");
 var import_node_os12 = require("os");
-var import_node_path70 = require("path");
+var import_node_path71 = require("path");
 var DESKTOP_BUNDLE_IDS = {
   production: ["com.alan-ai.desktop"],
   staging: ["com.alan-ai.desktop.staging"],
@@ -70408,7 +70937,7 @@ function serviceSpec({ config: config2, paths, self }) {
     profile: config2.profile,
     program: serviceCommand(config2.host, self, launcher),
     environment: config2.serviceEnvironment,
-    logPath: (0, import_node_path70.join)(paths.logs, "service.log"),
+    logPath: (0, import_node_path71.join)(paths.logs, "service.log"),
     associatedBundleIds: DESKTOP_BUNDLE_IDS[config2.profile]
   };
 }
@@ -70416,7 +70945,7 @@ async function installedServiceSpec(ctx) {
   const spec = serviceSpec(ctx);
   if (ctx.config.host === "app") return spec;
   const layout = installLayout(ctx.config.installDir, ctx.config.profile);
-  const installed = await (0, import_promises68.access)(layout.launcher).then(
+  const installed = await (0, import_promises70.access)(layout.launcher).then(
     () => true,
     () => false
   );
@@ -70544,7 +71073,7 @@ var manifestRevisionSchema = external_exports.object({ revision: external_export
 async function manifestRevision(path4) {
   let raw;
   try {
-    raw = JSON.parse(await (0, import_promises69.readFile)(path4, "utf8"));
+    raw = JSON.parse(await (0, import_promises71.readFile)(path4, "utf8"));
   } catch (error61) {
     throw new RuntimeFault("invalid_file", `Cannot read the skill manifest at ${path4}`, {
       cause: error61
@@ -70598,8 +71127,8 @@ async function runSkills(argv) {
 }
 
 // src/cli/commands/doctor.ts
-var import_promises72 = require("fs/promises");
-var import_node_path74 = require("path");
+var import_promises74 = require("fs/promises");
+var import_node_path75 = require("path");
 init_runtime_v2();
 
 // src/identity/credential.ts
@@ -70776,18 +71305,18 @@ async function authorizeDevice(input2) {
 }
 
 // src/identity/enroll.ts
-var import_promises70 = require("fs/promises");
+var import_promises72 = require("fs/promises");
 init_runtime_v2();
 
 // src/identity/installation.ts
 var import_node_crypto33 = require("crypto");
-var import_node_path71 = require("path");
+var import_node_path72 = require("path");
 init_zod();
 var installationFileSchema = external_exports.object({
   installationId: external_exports.uuid()
 });
 function installationPath(paths) {
-  return (0, import_node_path71.join)(paths.stateDir, "installation.json");
+  return (0, import_node_path72.join)(paths.stateDir, "installation.json");
 }
 async function ensureInstallationId(paths) {
   const path4 = installationPath(paths);
@@ -70880,13 +71409,13 @@ async function enrollFromGrantFile(input2) {
     clock: input2.clock,
     access: input2.access
   });
-  await (0, import_promises70.rm)(input2.grantPath, { force: true });
+  await (0, import_promises72.rm)(input2.grantPath, { force: true });
   return machine;
 }
 
 // src/identity/migrate-v1.ts
-var import_promises71 = require("fs/promises");
-var import_node_path72 = require("path");
+var import_promises73 = require("fs/promises");
+var import_node_path73 = require("path");
 init_runtime_v2();
 init_zod();
 var EXIT_POLL_MS = 200;
@@ -70907,11 +71436,11 @@ var ownerLeaseSchema = external_exports.looseObject({ pid: external_exports.numb
 function legacyConfigPath(home, profile) {
   switch (profile) {
     case "production":
-      return (0, import_node_path72.join)(home, ".alan", "agent", "config.json");
+      return (0, import_node_path73.join)(home, ".alan", "agent", "config.json");
     case "staging":
-      return (0, import_node_path72.join)(home, ".alan-staging", "agent", "config.json");
+      return (0, import_node_path73.join)(home, ".alan-staging", "agent", "config.json");
     default:
-      return (0, import_node_path72.join)(home, ".alan-dev", "agent", "config.json");
+      return (0, import_node_path73.join)(home, ".alan-dev", "agent", "config.json");
   }
 }
 async function findLegacyInstall(home, profile) {
@@ -70936,8 +71465,8 @@ async function scrubLegacyInstall(install2) {
   const scrubbed = { ...install2.config, migratedToRuntimeV2: true };
   for (const key of SCRUBBED_KEYS) delete scrubbed[key];
   await writeJsonFileAtomic(`${install2.configPath}.migrated-v1`, scrubbed);
-  await (0, import_promises71.rm)(install2.configPath, { force: true });
-  await (0, import_promises71.rm)(install2.ownerLeasePath, { force: true });
+  await (0, import_promises73.rm)(install2.configPath, { force: true });
+  await (0, import_promises73.rm)(install2.ownerLeasePath, { force: true });
 }
 async function exchangeCredential(deps) {
   const { config: config2 } = deps.install;
@@ -71046,7 +71575,7 @@ async function loadIdentity(paths, options = {}) {
 }
 
 // src/cli/commands/status.ts
-var import_node_path73 = require("path");
+var import_node_path74 = require("path");
 async function serviceStatus(ctx) {
   try {
     return await createServiceManager(ctx.host, ctx.config.profile).status();
@@ -71073,7 +71602,7 @@ async function runtimeState(ctx) {
   const running = await readRunningRuntime(ctx.paths.lock);
   if (running === null) return { state: "offline", pid: null, localApi: null };
   const discovery = await readJsonFile(
-    (0, import_node_path73.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE),
+    (0, import_node_path74.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE),
     localApiDiscoverySchema
   );
   const localApi = discovery.kind === "ok" && discovery.value.pid === running.pid ? {
@@ -71294,7 +71823,7 @@ async function runtimeCheck(ctx, status) {
     return check2("runtime", "warn", "No runtime is running for this profile");
   }
   const client = createRuntimeClient({
-    discoveryPath: (0, import_node_path74.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE)
+    discoveryPath: (0, import_node_path75.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE)
   });
   try {
     const live = await client.status(AbortSignal.timeout(LOCAL_TIMEOUT_MS));
@@ -71321,7 +71850,7 @@ async function runtimeCheck(ctx, status) {
   }
 }
 async function probeHolder(dir, conversationId) {
-  const launch = await readJsonFile((0, import_node_path74.join)(dir, "launch.json"), holderLaunchSchema);
+  const launch = await readJsonFile((0, import_node_path75.join)(dir, "launch.json"), holderLaunchSchema);
   if (launch.kind !== "ok") return null;
   try {
     const reply2 = await withTimeout(
@@ -71346,8 +71875,8 @@ async function probeHolder(dir, conversationId) {
   }
 }
 async function holdersCheck(ctx) {
-  const names = await (0, import_promises72.readdir)(ctx.paths.sessions).catch(() => []);
-  const holders = (await Promise.all(names.map((name) => probeHolder((0, import_node_path74.join)(ctx.paths.sessions, name), name)))).filter((facts) => facts !== null);
+  const names = await (0, import_promises74.readdir)(ctx.paths.sessions).catch(() => []);
+  const holders = (await Promise.all(names.map((name) => probeHolder((0, import_node_path75.join)(ctx.paths.sessions, name), name)))).filter((facts) => facts !== null);
   const dead = holders.filter((holder) => !holder.alive).length;
   return check2(
     "holders",
@@ -71358,10 +71887,10 @@ async function holdersCheck(ctx) {
 }
 async function freeBytesAt(path4) {
   try {
-    const stats = await (0, import_promises72.statfs)(path4);
+    const stats = await (0, import_promises74.statfs)(path4);
     return { path: path4, freeBytes: stats.bavail * stats.bsize };
   } catch (error61) {
-    const parent = (0, import_node_path74.dirname)(path4);
+    const parent = (0, import_node_path75.dirname)(path4);
     if (parent === path4) throw error61;
     return freeBytesAt(parent);
   }
@@ -71497,7 +72026,7 @@ async function runDoctor(argv, context = cliContext) {
 }
 
 // src/cli/commands/git-credential.ts
-var import_promises73 = require("fs/promises");
+var import_promises75 = require("fs/promises");
 var import_node_net4 = require("net");
 var MAX_RESPONSE_BYTES = 64 * 1024;
 async function readAll(stream) {
@@ -71607,7 +72136,7 @@ async function configure(argv) {
 }
 async function configureGitGateway(config2, gatewayUrl, signal) {
   const { launcher } = installLayout(config2.installDir, config2.profile);
-  const installed = await (0, import_promises73.access)(launcher).then(
+  const installed = await (0, import_promises75.access)(launcher).then(
     () => true,
     () => false
   );
@@ -71634,7 +72163,7 @@ async function runGitCredential(argv) {
 }
 
 // src/cli/commands/hold.ts
-var import_node_path75 = require("path");
+var import_node_path76 = require("path");
 init_agent2();
 init_runtime_v2();
 async function machineAccess(paths, log, conversationId, transport) {
@@ -71692,7 +72221,7 @@ async function runHold(argv) {
     const config2 = loadRuntimeConfig();
     const paths = runtimePaths(config2.stateDir);
     const log = __using(_stack, openFileLog(
-      (0, import_node_path75.join)(paths.logs, `holder-${launch.value.conversationId}.jsonl`),
+      (0, import_node_path76.join)(paths.logs, `holder-${launch.value.conversationId}.jsonl`),
       config2.logLevel,
       systemClock
     ));
@@ -71703,7 +72232,7 @@ async function runHold(argv) {
     );
     const transport = __using(_stack, createHttpTransport());
     const access7 = await machineAccess(paths, log, launch.value.conversationId, transport);
-    const credentialPath = (0, import_node_path75.join)(paths.tmp, "mcp", `${launch.value.conversationId}.json`);
+    const credentialPath = (0, import_node_path76.join)(paths.tmp, "mcp", `${launch.value.conversationId}.json`);
     const managedMcp = __using(_stack, access7.managedMcp === void 0 ? void 0 : createHelperMcpAccess({
       managedMcp: access7.managedMcp,
       conversationId: launch.value.conversationId,
@@ -71744,7 +72273,7 @@ async function runHold(argv) {
 }
 
 // src/cli/commands/hook.ts
-var import_node_path76 = require("path");
+var import_node_path77 = require("path");
 var RUNTIME_ANSWER_MS = 2e3;
 var DEBUG_VARIABLE = "ALAN_HOOK_DEBUG";
 function flag(argv, name) {
@@ -71776,7 +72305,7 @@ async function forwardHook(argv, io) {
     return "transcript outside provider root";
   }
   const verdict = await io.send(
-    (0, import_node_path76.join)(io.stateDir, LOCAL_API_DISCOVERY_FILE),
+    (0, import_node_path77.join)(io.stateDir, LOCAL_API_DISCOVERY_FILE),
     hookSignal,
     AbortSignal.timeout(RUNTIME_ANSWER_MS)
   );
@@ -71812,7 +72341,7 @@ async function runHook(argv, overrides = {}) {
 }
 
 // src/cli/commands/ingestion-hooks.ts
-var import_promises74 = require("fs/promises");
+var import_promises76 = require("fs/promises");
 var CODEX_TRUST_NOTE = "Codex runs new hooks only after you review them: open /hooks in Codex.";
 function isAction(value2) {
   return value2 === "enable" || value2 === "disable" || value2 === "status";
@@ -71835,7 +72364,7 @@ function errorMessage2(error61) {
   return error61 instanceof Error ? error61.message : String(error61);
 }
 async function exists5(path4) {
-  return (0, import_promises74.access)(path4).then(
+  return (0, import_promises76.access)(path4).then(
     () => true,
     () => false
   );
@@ -71938,10 +72467,10 @@ async function runIntegrationsCommand(argv) {
 }
 
 // src/cli/commands/legacy.ts
-var import_node_path78 = require("path");
+var import_node_path79 = require("path");
 
 // src/cli/commands/setup.ts
-var import_node_path77 = require("path");
+var import_node_path78 = require("path");
 init_zod();
 
 // src/cli/legacy.ts
@@ -72023,7 +72552,7 @@ async function grantFileCredential(argv, grantPath, ctx, deps) {
   return enrollFromGrantFile({
     paths: ctx.paths,
     storeKind: credentialStoreFlag(argv) ?? ctx.config.credentialStore,
-    grantPath: (0, import_node_path77.resolve)(grantPath),
+    grantPath: (0, import_node_path78.resolve)(grantPath),
     clock: deps.clock,
     access: ctx.access
   });
@@ -72099,7 +72628,7 @@ async function runSetup(argv, signal) {
   var _stack = [];
   try {
     const ctx = cliContext();
-    const log = __using(_stack, openFileLog((0, import_node_path77.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
+    const log = __using(_stack, openFileLog((0, import_node_path78.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
     const result = await setupMachine(argv, ctx, {
       enrollment: (apiUrl) => createEnrollmentClient({ apiUrl }),
       isProcessAlive,
@@ -72182,7 +72711,7 @@ async function runToken(argv, signal) {
       );
     }
     const ctx = cliContext();
-    const log = __using(_stack, openFileLog((0, import_node_path78.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
+    const log = __using(_stack, openFileLog((0, import_node_path79.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
     const result = await rotateMachineCredential(ctx, { clock: systemClock, log, signal });
     process.stdout.write(`${rotationMessage(result)}
 `);
@@ -72194,8 +72723,8 @@ async function runToken(argv, signal) {
 }
 
 // src/cli/commands/logout.ts
-var import_promises75 = require("fs/promises");
-var import_node_path79 = require("path");
+var import_promises77 = require("fs/promises");
+var import_node_path80 = require("path");
 init_runtime_v2();
 var RUNTIME_EXIT_WAIT_MS = 35e3;
 var TURN_END_WAIT_MS = 3e4;
@@ -72254,9 +72783,9 @@ async function stopHolder(launch, deps, outcome2) {
 }
 async function stopHeldRuns(ctx, deps, outcome2 = "aborted") {
   const stopped = [];
-  for (const name of await (0, import_promises75.readdir)(ctx.paths.sessions).catch(() => [])) {
+  for (const name of await (0, import_promises77.readdir)(ctx.paths.sessions).catch(() => [])) {
     const launch = await readJsonFile(
-      (0, import_node_path79.join)(ctx.paths.sessions, name, "launch.json"),
+      (0, import_node_path80.join)(ctx.paths.sessions, name, "launch.json"),
       holderLaunchSchema
     );
     if (launch.kind !== "ok") continue;
@@ -72293,13 +72822,13 @@ async function forgetMachineLocally(ctx) {
   const machine = await readMachineFile(ctx.paths);
   if (machine === null) return;
   await credentialStoreFor(ctx.paths, machine.credentialStore, ctx.access).clear();
-  await (0, import_promises75.rm)(ctx.paths.machine, { force: true });
+  await (0, import_promises77.rm)(ctx.paths.machine, { force: true });
 }
 async function runLogout(argv, signal) {
   var _stack = [];
   try {
     const ctx = cliContext();
-    const log = __using(_stack, openFileLog((0, import_node_path79.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
+    const log = __using(_stack, openFileLog((0, import_node_path80.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
     const result = await logoutMachine(argv, ctx, {
       api: (apiUrl, accessToken) => createApiClient({ apiUrl, accessToken }),
       stopHeldRuns,
@@ -72317,7 +72846,7 @@ async function runLogout(argv, signal) {
 
 // src/cli/commands/run.ts
 var import_node_fs24 = require("fs");
-var import_node_path83 = require("path");
+var import_node_path84 = require("path");
 
 // src/local-api/app-attachments.ts
 function createAppAttachments(clock) {
@@ -72394,9 +72923,9 @@ function createRunAppends() {
 
 // src/local-api/server.ts
 var import_node_crypto35 = require("crypto");
-var import_promises76 = require("fs/promises");
+var import_promises78 = require("fs/promises");
 var import_node_http4 = require("http");
-var import_node_path80 = require("path");
+var import_node_path81 = require("path");
 
 // src/local-api/guard.ts
 var import_node_crypto34 = require("crypto");
@@ -72713,9 +73242,9 @@ async function nextChangedRuns(bell, signal) {
   }
   if (signal.aborted) return [];
   await systemClock.sleep(50, signal);
-  const changed = [...bell.pending];
+  const changed2 = [...bell.pending];
   bell.pending.clear();
-  return changed;
+  return changed2;
 }
 async function writeChangedTurn(writer, runId, read) {
   const { ordinal, state } = read.changed;
@@ -72735,8 +73264,8 @@ async function streamLocalConversationMessages(deps, conversationId, limit, fram
     const bell = { pending: /* @__PURE__ */ new Set(), wake: void 0 };
     const slot = { current: null };
     const _subscription = __using(_stack, deps.appends.subscribe((runId) => {
-      const changed = runId ?? slot.current?.runId;
-      if (changed) bell.pending.add(changed);
+      const changed2 = runId ?? slot.current?.runId;
+      if (changed2) bell.pending.add(changed2);
       bell.wake?.();
     }));
     signal.addEventListener("abort", () => bell.wake?.(), { once: true });
@@ -73439,7 +73968,7 @@ async function serveLocalApi(deps) {
     startedAtMs,
     runtimeVersion: deps.runtimeVersion
   };
-  const discoveryPath = (0, import_node_path80.join)(deps.stateDir, LOCAL_API_DISCOVERY_FILE);
+  const discoveryPath = (0, import_node_path81.join)(deps.stateDir, LOCAL_API_DISCOVERY_FILE);
   await writeJsonFileAtomic(discoveryPath, discovery);
   const followers = startMaintenance({
     everyMs: limits.refreshEveryMs,
@@ -73473,7 +74002,7 @@ async function serveLocalApi(deps) {
       await watchedStatus[Symbol.asyncDispose]();
       const current = await readJsonFile(discoveryPath, localApiDiscoverySchema);
       if (current.kind === "ok" && current.value.token === token) {
-        await (0, import_promises76.rm)(discoveryPath, { force: true });
+        await (0, import_promises78.rm)(discoveryPath, { force: true });
       }
       await closeServer(server);
       log.info("local_api.closed", {});
@@ -73558,7 +74087,7 @@ function machineFeatureActions(deps) {
 }
 
 // src/cli/commands/machine-plane.ts
-var import_node_path82 = require("path");
+var import_node_path83 = require("path");
 
 // src/link/index.ts
 init_runtime_v2();
@@ -77226,7 +77755,7 @@ function refusalFailure(refusal2) {
 }
 
 // src/link/probe.ts
-var import_promises77 = require("dns/promises");
+var import_promises79 = require("dns/promises");
 var import_node_net5 = require("net");
 var import_node_tls2 = require("tls");
 var PROBE_TIMEOUT_MS4 = 5e3;
@@ -77262,7 +77791,7 @@ async function connectOnce(url3, clock) {
 }
 async function probeEndpoint(url3, clock) {
   try {
-    await (0, import_promises77.lookup)(url3.hostname);
+    await (0, import_promises79.lookup)(url3.hostname);
   } catch (error61) {
     const reason = classifyTransportFailure(error61);
     return reason === "other" ? "dns" : reason;
@@ -77711,7 +78240,7 @@ function createReconciler(host, lifecycle, log, signal) {
 }
 
 // src/uploader/index.ts
-var import_promises78 = require("fs/promises");
+var import_promises80 = require("fs/promises");
 init_runtime_v2();
 init_zod();
 var RETRY_DELAYS_MS = [250, 500, 1e3, 2e3, 5e3, 1e4, 3e4];
@@ -77859,7 +78388,7 @@ function startUploader({ api, runsDir, clock, log, archive }) {
   };
   const unsealedRunIds = async () => {
     const runIds = [];
-    for (const name of await (0, import_promises78.readdir)(runsDir).catch(() => [])) {
+    for (const name of await (0, import_promises80.readdir)(runsDir).catch(() => [])) {
       const runId = runIdSchema.safeParse(name);
       if (runId.success && !sealed.has(runId.data) && !archive?.has(runId.data))
         runIds.push(runId.data);
@@ -77874,13 +78403,13 @@ function startUploader({ api, runsDir, clock, log, archive }) {
     const dir = runDirectory(runsDir, runId);
     const progress = await readJsonFile(dir.upload, uploadProgressSchema);
     if (progress.kind !== "ok" || !progress.value.sealed) return false;
-    const sealedAt = (await (0, import_promises78.stat)(dir.upload)).mtimeMs;
+    const sealedAt = (await (0, import_promises80.stat)(dir.upload)).mtimeMs;
     if (clock.now() - sealedAt < options.sealedForMs) return false;
     return (await readLastRecord(dir.log))?.update.sessionUpdate === "_alan/run.ended";
   };
   const archivable = async (options) => {
     const found = [];
-    for (const name of await (0, import_promises78.readdir)(runsDir).catch(() => [])) {
+    for (const name of await (0, import_promises80.readdir)(runsDir).catch(() => [])) {
       const runId = runIdSchema.safeParse(name);
       if (!runId.success || archive?.has(runId.data)) continue;
       try {
@@ -77976,19 +78505,20 @@ async function startGitHubProxySidecar(deps) {
 function createCapabilityPublisher(deps) {
   const { inventory, log } = deps;
   let stored = null;
-  const publish = async (refresh, onlyChanges) => {
-    const capabilities = await inventory.scan({ refresh });
+  const publish = async (scanned, onlyChanges) => {
+    const capabilities = await scanned;
     if (onlyChanges && stored !== null && sameCapabilities(stored, capabilities)) return;
     if (await deps.push(capabilities)) stored = capabilities;
   };
   const report2 = (error61) => log.warn("capabilities.publish_failed", { error: error61 });
   return {
     connected: () => {
-      publish(false, false).catch(report2);
+      publish(inventory.latest(), false).catch(report2);
     },
     rescan: () => {
-      publish(true, true).catch(report2);
+      publish(inventory.scan({ refresh: true }), true).catch(report2);
     },
+    rescanIfChanged: () => publish(inventory.rescanIfChanged(), true).catch(report2),
     answerScan: async (request2) => {
       const capabilities = await inventory.scan({ refresh: request2.refresh === true });
       stored = capabilities;
@@ -78081,12 +78611,12 @@ async function startMachineNativeIngest(deps) {
 }
 
 // src/cli/commands/run-updates.ts
-var import_node_path81 = require("path");
+var import_node_path82 = require("path");
 init_runtime_v2();
 var UPDATE_CHECK_EVERY_MS = 6 * 60 * 60 * 1e3;
 var DEFERRED_RETRY_MS = 5 * 60 * 1e3;
 function isInstalledBundle(layout, bundlePath) {
-  return (0, import_node_path81.resolve)((0, import_node_path81.dirname)((0, import_node_path81.dirname)(bundlePath))) === (0, import_node_path81.resolve)(layout.versions);
+  return (0, import_node_path82.resolve)((0, import_node_path82.dirname)((0, import_node_path82.dirname)(bundlePath))) === (0, import_node_path82.resolve)(layout.versions);
 }
 async function settleUpgradeOnStart({
   layout,
@@ -78193,7 +78723,7 @@ function startRuntimeUpdates(options) {
       layout,
       release: npmRelease,
       tarball: await options.downloader.download(npmRelease.dist.tarball, signal),
-      tmpDir: (0, import_node_path81.join)(layout.root, ".downloads")
+      tmpDir: (0, import_node_path82.join)(layout.root, ".downloads")
     });
     await lifecycle.exclusive("upgrade", async () => {
       await recordPendingUpgrade(layout, currentVersion2, version2, clock.now());
@@ -78236,7 +78766,8 @@ function startRuntimeUpdates(options) {
 
 // src/cli/commands/machine-plane.ts
 var MAINTENANCE_EVERY_MS = 3e3;
-var CAPABILITY_RESCAN_MS = 15 * 6e4;
+var CAPABILITY_CHECK_MS = 15 * 6e4;
+var CAPABILITY_STALE_AFTER_MS = 60 * 6e4;
 var LOCAL_SKILLS_RESCAN_MS = 6e4;
 var CAPABILITY_MAX_AGE_MS = 6e4;
 var RUN_ARCHIVE_EVERY_MS = 6 * 60 * 6e4;
@@ -78424,7 +78955,7 @@ async function startMachinePlane(deps) {
                 [ALAN_MANAGED_SESSION_ENV]: "1"
               },
               cwd: paths.stateDir,
-              outputPath: (0, import_node_path82.join)(paths.logs, "holders.log")
+              outputPath: (0, import_node_path83.join)(paths.logs, "holders.log")
             },
             deps.holderIsolation
           );
@@ -78461,7 +78992,7 @@ async function startMachinePlane(deps) {
         }),
         local: { home: config2.home, machineId: identity.machineId },
         // Only a cloud sandbox's runtime has a git gateway; a person's own ~/.codex is theirs.
-        ...config2.gitGatewayUrl === null ? {} : { codexSkillsDir: (0, import_node_path82.join)(config2.codexHome, "skills") },
+        ...config2.gitGatewayUrl === null ? {} : { codexSkillsDir: (0, import_node_path83.join)(config2.codexHome, "skills") },
         log
       })
     );
@@ -78598,15 +79129,19 @@ async function startMachinePlane(deps) {
         probes: config2.providerProbes,
         clock,
         maxAgeMs: CAPABILITY_MAX_AGE_MS,
-        openCodeEntitlement: checkOpenCodeEntitlement
+        staleAfterMs: CAPABILITY_STALE_AFTER_MS,
+        openCodeEntitlement: checkOpenCodeEntitlement,
+        log
       }),
       push: (scanned) => link.pushCapabilities(scanned),
       log
     });
     stack.use(
       startMaintenance({
-        everyMs: CAPABILITY_RESCAN_MS,
-        jobs: [{ name: "capabilities.rescan", run: () => capabilities.rescan() }],
+        everyMs: CAPABILITY_CHECK_MS,
+        jobs: [
+          { name: "capabilities.rescan", run: () => capabilities.rescanIfChanged() }
+        ],
         clock,
         log
       })
@@ -78659,7 +79194,7 @@ async function startMachinePlane(deps) {
             git: createGitRunner({ env: cliEnvironment }),
             clock,
             log,
-            dir: (0, import_node_path82.join)(paths.stateDir, "checkout-freshness")
+            dir: (0, import_node_path83.join)(paths.stateDir, "checkout-freshness")
           },
           stopped.signal
         );
@@ -78953,7 +79488,7 @@ function lockWaitMs(argv) {
 }
 async function openManagedProviders(config2, paths) {
   const providerEnv = readCliEnvironment();
-  const bundledNpm = (0, import_node_path83.join)((0, import_node_path83.dirname)(process.execPath), "npm", "bin", "npm-cli.js");
+  const bundledNpm = (0, import_node_path84.join)((0, import_node_path84.dirname)(process.execPath), "npm", "bin", "npm-cli.js");
   const providerToolchain = config2.providerToolchain ?? (process.platform === "win32" && (0, import_node_fs24.existsSync)(bundledNpm) ? { node: process.execPath, npmCli: bundledNpm } : null);
   const npmPath = providerToolchain?.node ?? await resolveCommandOnPath("npm", providerEnv, process.platform);
   const npmOptions = npmPath === null || process.platform === "win32" && providerToolchain === null ? null : {
@@ -78961,7 +79496,7 @@ async function openManagedProviders(config2, paths) {
     ...providerToolchain === null ? {} : { argsBeforeNpm: [providerToolchain.npmCli] },
     env: providerEnv
   };
-  const providerNodeDir = providerToolchain?.node === void 0 ? void 0 : (0, import_node_path83.dirname)(providerToolchain.node);
+  const providerNodeDir = providerToolchain?.node === void 0 ? void 0 : (0, import_node_path84.dirname)(providerToolchain.node);
   const probeEnv = providerNodeDir === void 0 ? providerEnv : {
     ...providerEnv,
     PATH: `${providerNodeDir}${pathDelimiter(process.platform)}${envValue(providerEnv, "PATH")}`
@@ -78971,7 +79506,7 @@ async function openManagedProviders(config2, paths) {
     throw new Error("Provider installer is unavailable on this computer");
   };
   const managed = createManagedProviderClis({
-    root: (0, import_node_path83.join)(paths.stateDir, "provider-clis"),
+    root: (0, import_node_path84.join)(paths.stateDir, "provider-clis"),
     resolveVersion: npmOptions === null ? unavailable : createNpmVersionResolver(npmOptions),
     installPackage: npmOptions === null ? unavailable : createNpmPackageInstaller(npmOptions),
     probe: (executable, backendKind) => probeManagedProvider(executable, backendKind, canonicalProbeEnv)
@@ -79003,7 +79538,7 @@ async function runService(argv, stop, restart = new AbortController().signal) {
       waitMs: lockWaitMs(argv),
       signal: stop
     }));
-    const log = __using(_stack, openFileLog((0, import_node_path83.join)(paths.logs, "runtime.jsonl"), config2.logLevel, clock));
+    const log = __using(_stack, openFileLog((0, import_node_path84.join)(paths.logs, "runtime.jsonl"), config2.logLevel, clock));
     const lifecycle = createLifecycleQueue({ clock, log });
     const install2 = installLayout(config2.installDir, config2.profile);
     const bundlePath = process.argv[1] ?? "";
@@ -79037,7 +79572,7 @@ async function runService(argv, stop, restart = new AbortController().signal) {
         openCliEnvironment({
           env: readCliEnvironment(),
           platform: process.platform,
-          lastKnownGoodFile: (0, import_node_path83.join)(paths.stateDir, "login-path.json"),
+          lastKnownGoodFile: (0, import_node_path84.join)(paths.stateDir, "login-path.json"),
           clock,
           decorate: (env) => withPackagedAlanCodeEngine(env, bundlePath, process.platform)
         })
@@ -79214,17 +79749,17 @@ async function runServiceCommand(argv, ctx = cliContext()) {
 }
 
 // src/cli/commands/upgrade.ts
-var import_promises79 = require("fs/promises");
-var import_node_path84 = require("path");
+var import_promises81 = require("fs/promises");
+var import_node_path85 = require("path");
 function isNotNewer(version2, installed) {
   return installed !== null && isReleaseVersion(version2) && isReleaseVersion(installed) && compareVersions(version2, installed) <= 0;
 }
 async function installFromSource(source) {
   const { layout, from, ifNewer } = source;
-  const isTarball = (await (0, import_promises79.stat)(from)).isFile();
-  const downloads = (0, import_node_path84.join)(layout.root, ".downloads");
-  if (isTarball) await (0, import_promises79.mkdir)(downloads, { recursive: true, mode: 448 });
-  const scratch = isTarball ? await (0, import_promises79.mkdtemp)((0, import_node_path84.join)(downloads, "upgrade-")) : null;
+  const isTarball = (await (0, import_promises81.stat)(from)).isFile();
+  const downloads = (0, import_node_path85.join)(layout.root, ".downloads");
+  if (isTarball) await (0, import_promises81.mkdir)(downloads, { recursive: true, mode: 448 });
+  const scratch = isTarball ? await (0, import_promises81.mkdtemp)((0, import_node_path85.join)(downloads, "upgrade-")) : null;
   try {
     const sourceDir = scratch === null ? from : await extractPackageTarball(from, scratch);
     const version2 = await readPackageVersion(sourceDir);
@@ -79232,7 +79767,7 @@ async function installFromSource(source) {
     if (ifNewer && isNotNewer(version2, installed)) return { kind: "skipped", version: version2, installed };
     return { kind: "installed", ...await installVersion(layout, sourceDir) };
   } finally {
-    if (scratch !== null) await (0, import_promises79.rm)(scratch, { recursive: true, force: true });
+    if (scratch !== null) await (0, import_promises81.rm)(scratch, { recursive: true, force: true });
   }
 }
 async function runUpgrade(argv) {
@@ -79244,7 +79779,7 @@ async function runUpgrade(argv) {
   const layout = installLayout(config2.installDir, config2.profile);
   const outcome2 = await installFromSource({
     layout,
-    from: (0, import_node_path84.resolve)(from),
+    from: (0, import_node_path85.resolve)(from),
     ifNewer: hasFlag(argv, "--if-newer")
   });
   if (outcome2.kind === "skipped") {