halfcycle 0.4.14 → 0.4.16

package/bin/bin.bundle.mjs

@@ -14663,9 +14663,10 @@ var SESSION_START_MARKER_REL = ".claude/hooks/session-start-marker.sh";
 var GUARD_RUNNER_REL = ".claude/hooks/guard-runner.sh";
 var USER_PROMPT_REMINDER_REL = ".claude/hooks/user-prompt-reminder.sh";
 var USER_PROMPT_SCOPE_REL = ".claude/hooks/user-prompt-scope.sh";
+var USER_PROMPT_FINDINGS_REL = ".claude/hooks/user-prompt-findings.sh";
 var SESSION_END_MARKER_REL = ".claude/hooks/session-end-marker.sh";
 var WRITE_CAPABLE_TOOLS = ["Edit", "MultiEdit", "NotebookEdit", "Write"];
-var PRE_TOOL_USE_MATCHER = "^(Bash|Read|Grep|Write|Edit|MultiEdit|NotebookEdit|Agent)$";
+var PRE_TOOL_USE_MATCHER = "^(Bash|Read|Grep|Write|Edit|MultiEdit|NotebookEdit|Agent|PowerShell)$";
 function hookCommand(script, verb) {
   const invocation = `bash "$CLAUDE_PROJECT_DIR"/${script}`;
   return verb === void 0 ? invocation : `${invocation} ${verb}`;
@@ -14699,6 +14700,13 @@ var HALFCYCLE_HOOK_WIRING = [
     command: hookCommand(USER_PROMPT_SCOPE_REL),
     script: USER_PROMPT_SCOPE_REL
   },
+  {
+    event: "UserPromptSubmit",
+    matcher: null,
+    timeout: 10,
+    command: hookCommand(USER_PROMPT_FINDINGS_REL),
+    script: USER_PROMPT_FINDINGS_REL
+  },
   {
     event: "PreToolUse",
     matcher: PRE_TOOL_USE_MATCHER,
@@ -16393,7 +16401,7 @@ var SCOPE_PART_STATUSES = ["approved", "waiting"];
 var scopePartStatusSchema = external_exports.enum(SCOPE_PART_STATUSES);
 var SCOPE_ACTS = ["approve", "send-back"];
 var scopeActSchema = external_exports.enum(SCOPE_ACTS);
-var SCOPE_GIVEN_IN = ["console", "chat"];
+var SCOPE_GIVEN_IN = ["console", "chat", "autonomy"];
 var scopeGivenInSchema = external_exports.enum(SCOPE_GIVEN_IN);
 var scopeNoteSchema = descriptionText(SCOPE_NOTE_MAX);
 var scopeNoteWireSchema = external_exports.string().max(SCOPE_NOTE_MAX);
@@ -16425,7 +16433,8 @@ var phasePlanRecordedSchema = external_exports.object({
   typedApprovalOffered: external_exports.boolean(),
   reportedAt: utcIso8601,
   carriedFrom: external_exports.array(carriedFromEntrySchema).min(1).max(PHASE_PLAN_CHANGES_MAX).optional(),
-  movedUp: planMovedUpSchema.optional()
+  movedUp: planMovedUpSchema.optional(),
+  givenIn: scopeGivenInSchema.optional()
 }).strict();
 var phasePlanRefusedSchema = external_exports.object({
   outcome: external_exports.literal("refused"),
@@ -16823,6 +16832,12 @@ var PROJECT_RECORD_PATTERNS = [
   { pattern: "docs/build-records/build-tasks.json", name: () => "the build's progress record (build-tasks.json)" },
   { pattern: "docs/build-records/task-plan.json", name: () => "the build's plan (task-plan.json)", shrinkAsked: false },
   { pattern: "docs/build-records", name: (file2) => `a closed phase's Build Record (${file2})` },
+  {
+    pattern: ".claude/context/tasks/*",
+    name: (file2) => `a task's notes for this phase (${file2})`,
+    shrinkAsked: false,
+    deleteAsked: false
+  },
   { pattern: ".claude/context", name: (file2) => `the project's working notes (${file2})` }
 ];
 var observedCountSchema = external_exports.number({ error: `must be a whole number from 0 to ${OBSERVED_COUNT_MAX}` }).int({ error: `must be a whole number from 0 to ${OBSERVED_COUNT_MAX}` }).min(0, { error: `must be a whole number from 0 to ${OBSERVED_COUNT_MAX}` }).max(OBSERVED_COUNT_MAX, { error: `must be a whole number from 0 to ${OBSERVED_COUNT_MAX}` });
@@ -17645,6 +17660,14 @@ var REVIEW_PART_CHANGES = Object.freeze([...PHASE_PLAN_CHANGE_KINDS, "not-in-pla
 var reviewPartChangeSchema = external_exports.enum(REVIEW_PART_CHANGES);
 var REVIEW_DECISIONS = Object.freeze(["accepted", "carried", "dropped"]);
 var reviewDecisionSchema = external_exports.enum(REVIEW_DECISIONS);
+var reviewGivenInSchema = scopeGivenInSchema.extract(["autonomy"]);
+function checkReviewGivenIn(v, ctx) {
+  if (v.givenIn === void 0)
+    return;
+  if (v.decision !== "accepted" && v.decision !== "carried") {
+    ctx.addIssue({ code: "custom", path: ["givenIn"], message: "is present only on a part accepted or carried" });
+  }
+}
 function actOf(decision) {
   if (decision === "accepted")
     return "accept";
@@ -17712,6 +17735,25 @@ var reviewRefusedSchema = external_exports.object({
 function bareReviewOutcome(outcome) {
   return external_exports.object({ outcome: external_exports.literal(outcome) }).strict();
 }
+var reviewClosedByAutonomySchema = external_exports.object({
+  outcome: external_exports.literal("closed-by-autonomy"),
+  accepted: external_exports.number().int().min(0).max(REVIEW_PARTS_MAX),
+  carried: external_exports.number().int().min(0).max(REVIEW_PARTS_MAX)
+}).strict().refine((v) => v.accepted + v.carried <= REVIEW_PARTS_MAX, {
+  message: "cannot exceed the parts a round holds",
+  path: ["carried"]
+});
+var AUTONOMY_WAIT_REASONS = ["unchecked-claims", "built-without-approval"];
+var autonomyWaitReasonSchema = external_exports.enum(AUTONOMY_WAIT_REASONS);
+var reviewAutonomyWaitsSchema = external_exports.object({
+  outcome: external_exports.literal("autonomy-waits"),
+  reason: autonomyWaitReasonSchema,
+  count: external_exports.number().int().min(1),
+  parts: external_exports.array(external_exports.object({ part: systemPartIdSchema, name: systemPartSchema.shape.name }).strict()).min(1).max(REVIEW_PARTS_MAX)
+}).strict().refine((v) => v.reason !== "built-without-approval" || v.count === v.parts.length, {
+  message: "counts the parts it names",
+  path: ["count"]
+});
 var openReviewResultSchema = external_exports.discriminatedUnion("outcome", [
   reviewOpenedSchema,
   reviewTasksOpenSchema,
@@ -17720,7 +17762,9 @@ var openReviewResultSchema = external_exports.discriminatedUnion("outcome", [
   reviewOutstandingSchema,
   reviewCleanOverFindingsSchema,
   reviewRefusedSchema,
-  bareReviewOutcome("unavailable")
+  bareReviewOutcome("unavailable"),
+  reviewClosedByAutonomySchema,
+  reviewAutonomyWaitsSchema
 ]);
 var reviewPhaseNotOpenSchema = external_exports.object({
   statusCode: external_exports.literal(409),
@@ -17834,6 +17878,7 @@ var reviewViewPartSchema = external_exports.object({
   decidable: external_exports.boolean(),
   waiting: external_exports.boolean(),
   decision: reviewDecisionSchema.optional(),
+  givenIn: reviewGivenInSchema.optional(),
   reason: reviewNoteSchema.optional(),
   carriedTo: reviewCarriedToSchema.optional(),
   sentBack: external_exports.array(reviewSentBackSchema),
@@ -17861,6 +17906,7 @@ var reviewViewPartSchema = external_exports.object({
   if (v.change === "not-in-plan" && !v.built) {
     ctx.addIssue({ code: "custom", path: ["built"], message: "is always true for a part outside the plan" });
   }
+  checkReviewGivenIn(v, ctx);
 });
 var reviewPhaseNumberSchema = external_exports.number().int().min(1).nullable();
 var phaseReviewNoneSchema = external_exports.object({
@@ -18286,6 +18332,87 @@ var reviewAnswerResultSchema = external_exports.discriminatedUnion("outcome", [
   bareOutcome2("unavailable")
 ]);
 
+// ../events/dist/owner-waits.js
+var OWNER_WAIT_ITEMS = Object.freeze([
+  Object.freeze({ id: "delete-users-data", words: "Deleting or replacing data people already have." }),
+  Object.freeze({
+    id: "change-promises",
+    words: "Changing what the product promises its users, such as pricing, terms or privacy."
+  }),
+  Object.freeze({ id: "spend-or-sign-up", words: "Anything that costs money or signs up for a service." }),
+  Object.freeze({ id: "publish-or-release", words: "Publishing or releasing to users." }),
+  Object.freeze({ id: "reshape-shared-data", words: "Dropping or reshaping stored data that other parts read." }),
+  Object.freeze({ id: "change-standing-rule", words: "Changing a standing rule." })
+]);
+var OWNER_WAIT_ITEM_IDS = Object.freeze(OWNER_WAIT_ITEMS.map((item) => item.id));
+var ownerWaitItemIdSchema = external_exports.enum(OWNER_WAIT_ITEM_IDS);
+var OWNER_WAIT_FIXED_COUNT = OWNER_WAIT_ITEMS.length;
+var OWNER_WAIT_ADDITIONS_MAX = 20;
+var OWNER_WAIT_TEXT_MAX = 240;
+var ownerWaitItemRefSchema = external_exports.union([
+  external_exports.number().int().min(1),
+  external_exports.string().uuid({ message: "must be a number from 1 to 6, or the id shown beside an added item" })
+]);
+var ownerWaitText = descriptionText(OWNER_WAIT_TEXT_MAX);
+var ownerWaitAddRequestSchema = external_exports.object({
+  engagementId: external_exports.string().min(1),
+  text: ownerWaitText,
+  reason: ownerWaitText
+}).strict();
+var ownerWaitAddResultSchema = external_exports.discriminatedUnion("outcome", [
+  external_exports.object({ outcome: external_exports.literal("added"), id: external_exports.string().uuid(), addedAt: utcIso8601 }).strict(),
+  external_exports.object({ outcome: external_exports.literal("refused"), reason: external_exports.literal("too-many") }).strict()
+]);
+var ownerWaitUndoableSchema = external_exports.enum(["yes", "no"]);
+var ownerWaitDeclareRequestSchema = external_exports.object({
+  engagementId: external_exports.string().min(1),
+  item: ownerWaitItemRefSchema,
+  question: ownerWaitText,
+  recommendation: ownerWaitText,
+  task: buildTaskIdSchema.optional(),
+  by: agentNameSchema.optional(),
+  undoable: ownerWaitUndoableSchema.optional(),
+  how: statementText(STATEMENT_MAX).optional()
+}).strict().refine((r) => r.undoable === "yes" === (r.how !== void 0), {
+  message: "says how to undo it exactly when it can be undone",
+  path: ["how"]
+});
+var OWNER_WAIT_DECLARE_REFUSALS = ["no-open-phase", "unknown-item", "say-if-undoable"];
+var ownerWaitDeclareResultSchema = external_exports.discriminatedUnion("outcome", [
+  external_exports.object({ outcome: external_exports.literal("recorded"), id: external_exports.string().uuid(), say: external_exports.string().min(1) }).strict(),
+  external_exports.object({
+    outcome: external_exports.literal("go-ahead"),
+    id: external_exports.string().uuid(),
+    callId: external_exports.number().int().positive(),
+    say: external_exports.string().min(1)
+  }).strict(),
+  external_exports.object({ outcome: external_exports.literal("refused"), reason: external_exports.enum(OWNER_WAIT_DECLARE_REFUSALS) }).strict()
+]);
+var ownerWaitAddedItemSchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  words: external_exports.string().min(1),
+  reason: external_exports.string().min(1),
+  addedAt: utcIso8601
+}).strict();
+var ownerWaitListSchema = external_exports.object({
+  fixed: external_exports.array(external_exports.object({ id: ownerWaitItemIdSchema, words: external_exports.string().min(1) }).strict()).length(OWNER_WAIT_FIXED_COUNT),
+  added: external_exports.array(ownerWaitAddedItemSchema).max(OWNER_WAIT_ADDITIONS_MAX)
+}).strict();
+var ownerWaitDeclarationSchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  fixedItem: ownerWaitItemIdSchema.nullable(),
+  addition: external_exports.object({ id: external_exports.string().uuid(), words: external_exports.string().min(1) }).strict().nullable(),
+  question: external_exports.string().min(1),
+  recommendation: external_exports.string().min(1),
+  task: buildTaskIdSchema.nullable(),
+  declaredAt: utcIso8601
+}).strict().refine((d) => d.fixedItem === null !== (d.addition === null), {
+  message: "names exactly one item: a fixed one or an added one",
+  path: ["fixedItem"]
+});
+var ownerWaitDeclarationsSchema = external_exports.object({ declarations: external_exports.array(ownerWaitDeclarationSchema) }).strict();
+var OWNER_WAIT_TOO_MANY = `This project already has ${String(OWNER_WAIT_ADDITIONS_MAX)} things added to what waits for the owner. Ask the owner to take one off in the console first.`;
+
 // ../events/dist/pacing.js
 var CLAUDE_PLANS = Object.freeze([
   Object.freeze({ id: "pro", words: "Pro", startingAgents: 2 }),
@@ -18417,10 +18544,212 @@ function paceStatusLineOf(percent, window) {
   return `Halfcycle \xB7 ${String(Math.round(percent))}% of this ${PACE_WINDOW_WORDS[window]} used`;
 }
 
+// ../events/dist/autonomy.js
+var AUTONOMY_CHANGED_IN = ["console", "chat"];
+var autonomyChangedInSchema = external_exports.enum(AUTONOMY_CHANGED_IN);
+var autonomySettingsSchema = external_exports.object({
+  on: external_exports.boolean(),
+  // whether builds run on their own
+  mayPublish: external_exports.boolean(),
+  // whether builds may publish or release without waiting
+  maySpend: external_exports.boolean(),
+  // whether builds may spend money or sign up without waiting
+  changedAt: utcIso8601.nullable(),
+  // when the setting last changed; null if never
+  changedIn: autonomyChangedInSchema.nullable()
+  // where it last changed; null if never
+}).strict().refine((v) => v.changedAt === null === (v.changedIn === null), {
+  message: "says when and where it changed, or neither",
+  path: ["changedIn"]
+});
+var autonomyChangeRequestSchema = external_exports.object({
+  on: external_exports.boolean(),
+  // the switch
+  mayPublish: external_exports.boolean(),
+  // the publish box
+  maySpend: external_exports.boolean()
+  // the spend box
+}).strict();
+var AUTONOMY_CHAT_ACTS = ["on", "off"];
+var autonomyChatActSchema = external_exports.enum(AUTONOMY_CHAT_ACTS);
+var autonomyChatRequestSchema = external_exports.object({
+  act: autonomyChatActSchema
+  // what the owner typed
+}).strict();
+var autonomyChatResultSchema = external_exports.discriminatedUnion("outcome", [
+  external_exports.object({
+    outcome: external_exports.literal("recorded"),
+    on: external_exports.boolean()
+    // whether builds now run on their own
+  }).strict(),
+  external_exports.object({ outcome: external_exports.literal("not-owner") }).strict(),
+  external_exports.object({ outcome: external_exports.literal("no-owner") }).strict(),
+  external_exports.object({ outcome: external_exports.literal("not-offered") }).strict(),
+  external_exports.object({ outcome: external_exports.literal("unavailable") }).strict()
+]);
+var autonomyStateSchema = external_exports.object({
+  on: external_exports.boolean(),
+  // whether builds run on their own
+  mayPublish: external_exports.boolean(),
+  // whether builds may publish or release without waiting
+  maySpend: external_exports.boolean()
+  // whether builds may spend money or sign up without waiting
+}).strict();
+var autonomyStateFileSchema = autonomyStateSchema.extend({
+  readAt: utcIso8601
+  // when this copy was read from Halfcycle
+}).strict();
+var AUTONOMY_STATE_FILE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var AUTONOMY_ACTIVITY_KINDS = ["went-ahead", "waiting", "approved", "closed", "waiting-on-owner"];
+var autonomyActivityKindSchema = external_exports.enum(AUTONOMY_ACTIVITY_KINDS);
+var autonomyActivityRowSchema = external_exports.object({
+  kind: autonomyActivityKindSchema,
+  // what happened
+  phase: scopePhaseSchema,
+  // the phase it happened in
+  question: ownerWaitText.optional(),
+  // the agent's question, for a decision
+  chose: ownerWaitText.optional(),
+  // what the agent chose or recommends, for a decision
+  undoable: ownerWaitUndoableSchema.optional(),
+  // whether the agent says it can be undone
+  how: statementText(STATEMENT_MAX).optional(),
+  // how to undo it, when it can be
+  at: utcIso8601
+  // when it happened
+}).strict().superRefine((row, ctx) => {
+  const decision = row.kind === "went-ahead" || row.kind === "waiting";
+  if (decision && row.question === void 0) {
+    ctx.addIssue({ code: "custom", message: "a decision says its question", path: ["question"] });
+  }
+  if (!decision) {
+    for (const key of ["question", "chose", "undoable", "how"]) {
+      if (row[key] !== void 0) {
+        ctx.addIssue({ code: "custom", message: "only a decision carries this", path: [key] });
+      }
+    }
+  }
+  if (row.kind === "went-ahead") {
+    if (row.chose === void 0) {
+      ctx.addIssue({ code: "custom", message: "a decision that went ahead says what was chosen", path: ["chose"] });
+    }
+    if (row.undoable === void 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: "a decision that went ahead says whether it can be undone",
+        path: ["undoable"]
+      });
+    }
+  }
+  if (row.kind === "waiting" && (row.undoable !== void 0 || row.how !== void 0)) {
+    ctx.addIssue({ code: "custom", message: "a waiting decision has not been made yet", path: ["undoable"] });
+  }
+  if (row.kind === "went-ahead" && row.undoable === "yes" !== (row.how !== void 0)) {
+    ctx.addIssue({ code: "custom", message: "says how to undo it exactly when it can be undone", path: ["how"] });
+  }
+});
+var autonomyActivitySchema = external_exports.object({
+  rows: external_exports.array(autonomyActivityRowSchema)
+  // newest first
+}).strict();
+var savedIdSchema = external_exports.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "must be lower-case letters, digits and single hyphens");
+var SAVED_REF_PREFIX = "refs/halfcycle/saved/";
+function savedRefOf(id) {
+  return `${SAVED_REF_PREFIX}${id}`;
+}
+var SAVED_KEEP_MS = 7 * 24 * 60 * 60 * 1e3;
+var SAVED_DIR_NAME = "saved";
+var SAVED_FILE_NAME = "saved.json";
+var SAVED_COPIES_DIR_NAME = "files";
+var SAVED_REPOSITORY_FILE_NAME = "repository";
+var SAVED_HALF_WRITTEN_GRACE_MS = 6e4;
+function savedPruneAnswer(save, here) {
+  const old = (t) => !Number.isFinite(t) || here.now - t > SAVED_KEEP_MS;
+  if (save.refMadeAt !== null) {
+    if (!old(save.refMadeAt))
+      return "keep";
+    return save.folderChangedAt === null ? "remove-ref" : "remove-ref-then-folder";
+  }
+  if (save.folderChangedAt === null || !Number.isFinite(save.folderChangedAt))
+    return "keep";
+  const ours = save.folderRepository === null || here.repository !== null && save.folderRepository === here.repository;
+  const wait = ours ? SAVED_HALF_WRITTEN_GRACE_MS : SAVED_KEEP_MS;
+  return here.now - save.folderChangedAt > wait ? "remove-folder" : "keep";
+}
+function isProjectRelativePath(p) {
+  if (p.length === 0 || hasControlCharacter(p))
+    return false;
+  if (p.startsWith("/") || p.startsWith("\\") || /^[A-Za-z]:/.test(p))
+    return false;
+  return p.split(/[\\/]/).every((segment) => segment !== "" && windowsNameOf(segment) !== "" && !isGitFolderSegment(segment));
+}
+function windowsNameOf(segment) {
+  return segment.replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u2064\u206a-\u206f\ufeff]/g, "").split(":")[0].replace(/[. ]+$/, "").toLowerCase();
+}
+function isGitFolderSegment(segment) {
+  const t = windowsNameOf(segment);
+  return t === ".git" || /^git~\d+$/.test(t);
+}
+var SAVED_PATH_KEPT_IN = ["commit", "copy"];
+var savedPathSchema = external_exports.object({
+  path: external_exports.string().max(4096).refine(isProjectRelativePath, { message: "must be a path inside the project" }),
+  // the file, relative to the project
+  keptIn: external_exports.enum(SAVED_PATH_KEPT_IN)
+  // in the save's commit, or copied beside this file
+}).strict();
+var savedCommitSchema = external_exports.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/, "must be a full commit hash");
+var savedBranchSchema = external_exports.object({
+  name: external_exports.string().min(1).max(255).refine((n) => !hasControlCharacter(n) && !n.startsWith("-") && !n.includes("..") && n !== "HEAD", {
+    message: "must be a branch name"
+  }),
+  // the branch's name
+  commit: savedCommitSchema
+  // the commit it pointed at
+}).strict();
+var savedSchema = external_exports.object({
+  id: savedIdSchema,
+  // what restore is typed with
+  savedAt: utcIso8601,
+  // when the copy was made
+  ref: external_exports.string().min(1),
+  // where the saved commit is kept
+  what: external_exports.string().min(1).max(2e3),
+  // what the action would have changed, in words
+  paths: external_exports.array(savedPathSchema),
+  // every saved file
+  branches: external_exports.array(savedBranchSchema)
+  // every saved line of work
+}).strict().refine((s) => s.ref === savedRefOf(s.id), { message: "must be the ref of this save", path: ["ref"] });
+var AUTONOMY_A4 = 'Builds in this project now run on their own. Turn it off with "autonomy off", or in the console.';
+var AUTONOMY_A5 = "Builds in this project wait for you again.";
+function withoutFinalStop(text) {
+  return text.endsWith(".") ? text.slice(0, -1) : text;
+}
+function autonomyA9(what, id) {
+  return `Halfcycle saved a copy before this: ${withoutFinalStop(what)}. To bring it back, run: ${HALFCYCLE_COMMAND} restore ${id} (kept for 7 days).`;
+}
+function autonomyA10(typeSentence, item) {
+  return `${typeSentence} Builds run on their own here, but this still waits for the owner. Declare it with halfcycle_declare_owner_wait, item ${String(item)}, and carry on with other work.`;
+}
+function autonomyA11(typeSentence) {
+  return `${typeSentence} This is never done while builds run on their own. Find a way that does not need the secrets.`;
+}
+function autonomyA12(typeSentence, reason) {
+  return `${typeSentence} Halfcycle could not save a copy first (${reason}), so it was stopped. Nothing was changed.`;
+}
+var AUTONOMY_COULD_NOT_TELL_SENTENCE = "Halfcycle: This step can delete, overwrite, publish or show something that cannot be taken back, and Halfcycle could not work out what.";
+var AUTONOMY_COULD_NOT_TELL_REASON = "it could not tell what this would change";
+var AUTONOMY_SAVE_TOO_LARGE_REASON = "more than 200 MB of files would have to be copied";
+var AUTONOMY_SAVE_NO_HISTORY_REASON = "the project has no saved history yet";
+var AUTONOMY_SAVE_FAILED_REASON = "the copy could not be made";
+var AUTONOMY_SAVE_NOT_COVERED_REASON = "this kind of change cannot be saved yet";
+var AUTONOMY_A18 = "Halfcycle cannot check PowerShell commands while builds run on their own. Use Bash for this; nothing was changed.";
+
 // dist/hook-protocol.js
 import { writeSync } from "node:fs";
-function emitBlock(reason) {
-  process.stdout.write(JSON.stringify({ decision: "block", reason }) + "\n");
+function emitBlock(reason, systemMessage) {
+  const body = systemMessage === void 0 ? { decision: "block", reason } : { decision: "block", reason, systemMessage };
+  process.stdout.write(JSON.stringify(body) + "\n");
   process.exit(0);
 }
 function preToolUseReplyText(answer, text = "", agentLine) {
@@ -18441,40 +18770,65 @@ ${agentLine}`;
 function preToolUseNoticeText(text) {
   return JSON.stringify({ systemMessage: text });
 }
+function preToolUseSavedText(text) {
+  return JSON.stringify({ systemMessage: text, hookSpecificOutput: { hookEventName: "PreToolUse", additionalContext: text } });
+}
 function nonBlockingReply(event, text) {
-  if (event === "PostToolUse" || event === "SessionStart") {
+  if (event === "SessionStart") {
     return JSON.stringify({
       systemMessage: text,
       hookSpecificOutput: { hookEventName: event, additionalContext: text }
     });
   }
+  if (event === "PostToolUse") {
+    return JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: text } });
+  }
   return JSON.stringify({ systemMessage: text });
 }
 function hookReply(event) {
   const queued = [];
+  const forAgent = [];
   return {
     notice(text) {
       queued.push(text);
     },
-    block(reason) {
+    agentContext(text) {
+      forAgent.push(text);
+    },
+    block(reason, systemMessage) {
       const carried = queued.splice(0);
-      return emitBlock(carried.length === 0 ? reason : [reason, ...carried].join("\n"));
+      return emitBlock(carried.length === 0 ? reason : [reason, ...carried].join("\n"), systemMessage);
     },
     flush() {
-      if (queued.length === 0)
-        return;
       const text = queued.splice(0).join("\n");
+      const context = event === "PostToolUse" ? forAgent.splice(0).join("\n") : "";
       const code = process.exitCode;
       if (code !== void 0 && code !== null && Number(code) !== 0) {
-        writeSync(2, `${text}
+        if (text !== "")
+          writeSync(2, `${text}
+`);
+        return;
+      }
+      if (context !== "") {
+        process.stdout.write(`${postToolUseReply(text, context)}
 `);
         return;
       }
+      if (text === "")
+        return;
       process.stdout.write(`${nonBlockingReply(event, text)}
 `);
     }
   };
 }
+function postToolUseReply(notice, context) {
+  const additionalContext = notice === "" ? context : `${notice}
+${context}`;
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext } });
+}
+function userPromptContextReply(context) {
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: context } });
+}
 function infraWarningText() {
   return "[Halfcycle] WARNING: Halfcycle's check service could not be reached, so nothing was checked this time. The session continues without checks.";
 }
@@ -18827,7 +19181,8 @@ function spawnGit(args2, cwd, timeoutMs, extra) {
     encoding: "utf-8",
     ...timeoutMs === void 0 ? {} : { timeout: timeoutMs },
     ...extra?.input === void 0 ? {} : { input: extra.input },
-    ...extra?.maxBuffer === void 0 ? {} : { maxBuffer: extra.maxBuffer }
+    ...extra?.maxBuffer === void 0 ? {} : { maxBuffer: extra.maxBuffer },
+    ...extra?.env === void 0 ? {} : { env: { ...process.env, ...extra.env } }
   });
 }
 function git(args2, cwd, timeoutMs, extra) {
@@ -18903,6 +19258,9 @@ function remoteHeadLine(remote, repoRoot, timeoutMs, globalArgs = []) {
 function readGitForFacts(args2, cwd, timeoutMs, input) {
   return git(args2, cwd, timeoutMs, { maxBuffer: 64 * 1024 * 1024, ...input === void 0 ? {} : { input } });
 }
+function gitForSave(args2, cwd, timeoutMs, extra = {}) {
+  return git(args2, cwd, timeoutMs, { maxBuffer: 64 * 1024 * 1024, ...extra });
+}
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 function resolveDiffBase(repoRoot, explicit) {
   const named = (explicit ?? "").trim();
@@ -18964,6 +19322,15 @@ function getRefToWorktreeChangedFiles(ref, repoRoot) {
   const files = result.value.split("\n").map((l) => l.trim()).filter(Boolean);
   return { ok: true, value: files };
 }
+function getUntrackedFiles(repoRoot, paths) {
+  if (paths.length === 0)
+    return { ok: true, value: [] };
+  const pathspecs = paths.map((p) => `:(literal)${p}`);
+  const result = git(["ls-files", "--others", "--exclude-standard", "-z", "--", ...pathspecs], repoRoot);
+  if (!result.ok)
+    return result;
+  return { ok: true, value: result.value.split("\0").filter(Boolean) };
+}
 var PROVE_GIT_TIMEOUT_MS = 3e4;
 function pathsDifferingFromHead(repoRoot, timeoutMs = PROVE_GIT_TIMEOUT_MS) {
   const result = git(["--no-optional-locks", "status", "--porcelain=v1", "-z", "--no-renames", "--untracked-files=all"], repoRoot, timeoutMs);
@@ -20767,6 +21134,17 @@ var MARKER_TTL_MS = 24 * 60 * 60 * 1e3;
 var MARKER_PREFIX = "halfcycle-session-";
 var MARKER_SUFFIX = ".ref";
 var DEDUPE_SUFFIX = ".eval";
+var OWN_WORK_PREFIX = "halfcycle-own-";
+var OWN_WORK_SUFFIX = ".jsonl";
+var FINDINGS_PREFIX = "halfcycle-findings-";
+var FINDINGS_SUFFIX = ".json";
+var FINDINGS_ID_SOURCE = "^[A-Za-z0-9-]{1,128}$";
+var FINDINGS_ID = new RegExp(FINDINGS_ID_SOURCE);
+function findingsPath(sessionId) {
+  if (typeof sessionId !== "string" || !FINDINGS_ID.test(sessionId))
+    return null;
+  return join6(markerDir(), `${FINDINGS_PREFIX}${sessionId}${FINDINGS_SUFFIX}`);
+}
 function markerDir() {
   const raw = process.env["TMPDIR"] || tmpdir();
   return raw.replace(/\/+$/, "");
@@ -20873,6 +21251,7 @@ function digestChangeState(base, entries) {
 function orphanSweep(repoRoot, refKnown, keepSessionId, now = Date.now(), livenessCommon) {
   if (livenessCommon !== void 0)
     sweepLiveness(livenessCommon, now);
+  sweepSessionFiles(keepSessionId, now);
   const dir = markerDir();
   const hash2 = repoHash(repoRoot);
   const keepName = keepSessionId ? markerFileName(repoRoot, keepSessionId) : markerFileName(repoRoot);
@@ -20912,6 +21291,33 @@ function orphanSweep(repoRoot, refKnown, keepSessionId, now = Date.now(), livene
     }
   }
 }
+function sweepSessionFiles(keepSessionId, now) {
+  const dir = markerDir();
+  let names;
+  try {
+    names = readdirSync3(dir);
+  } catch {
+    return;
+  }
+  const kinds = [
+    [FINDINGS_PREFIX, FINDINGS_SUFFIX],
+    [OWN_WORK_PREFIX, OWN_WORK_SUFFIX]
+  ];
+  for (const name of names) {
+    for (const [prefix, suffix] of kinds) {
+      if (!name.startsWith(prefix) || !name.endsWith(suffix))
+        continue;
+      if (keepSessionId !== void 0 && name === `${prefix}${keepSessionId}${suffix}`)
+        continue;
+      const full = join6(dir, name);
+      try {
+        if (now - statSync(full).mtimeMs > MARKER_TTL_MS)
+          unlinkSync3(full);
+      } catch {
+      }
+    }
+  }
+}
 function observeThrottlePath(folder) {
   return join6(markerDir(), `${MARKER_PREFIX}${repoHash(folder)}.observe-throttle`);
 }
@@ -21788,6 +22194,21 @@ function parseTimeLog(text) {
   }
   return out;
 }
+function readSessionTimeLines(sessionId, deps = {}) {
+  try {
+    const read = readConfig(deps.env ?? process.env);
+    if (read.config === null)
+      return [];
+    const path = timeLogPath(read.config.guardEngagementId, deps.home);
+    if (path === null)
+      return [];
+    const needle = JSON.stringify(sessionId);
+    const kept = readFileSync11(path, "utf-8").split("\n").filter((raw) => raw.includes(needle));
+    return parseTimeLog(kept.join("\n")).filter((line2) => line2.session === sessionId);
+  } catch {
+    return [];
+  }
+}
 function shortHash(text) {
   return createHash2("sha256").update(text, "utf8").digest("hex").slice(0, 16);
 }
@@ -21809,8 +22230,8 @@ function separatorOf(path) {
 function subagentsFolderOf(transcript) {
   if (!transcript.endsWith(".jsonl") || transcript.length === ".jsonl".length)
     return null;
-  const sep4 = separatorOf(transcript);
-  return `${transcript.slice(0, -".jsonl".length)}${sep4}subagents`;
+  const sep5 = separatorOf(transcript);
+  return `${transcript.slice(0, -".jsonl".length)}${sep5}subagents`;
 }
 function subagentRecordName(agentId) {
   return /^[A-Za-z0-9_-]+$/.test(agentId) ? `agent-${agentId}.jsonl` : null;
@@ -22350,7 +22771,7 @@ async function pruneTimeLog(path, openedAt) {
     written = true;
     let seen = Buffer.byteLength(text, "utf-8");
     for (; ; ) {
-      await new Promise((resolve6) => setTimeout(resolve6, PRUNE_SETTLE_MS));
+      await new Promise((resolve8) => setTimeout(resolve8, PRUNE_SETTLE_MS));
       const after = readFileSync11(aside);
       if (after.length <= seen)
         break;
@@ -22468,101 +22889,634 @@ async function sendTimeRecord(deps = {}) {
   }
 }
 
-// dist/hooks/post-tool-use.js
-var HANDLED_EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
-async function runPostToolUse(readSeat = readSeatConfiguration) {
-  const reply = hookReply("PostToolUse");
-  await evaluateEdit(reply, readSeat);
-  reply.flush();
+// dist/own-work.js
+import { appendFileSync as appendFileSync3, lstatSync, readFileSync as readFileSync12, realpathSync as realpathSync4 } from "node:fs";
+import { basename, dirname as dirname5, isAbsolute, join as join10, relative as relative4, resolve as resolve3, sep as sep2 } from "node:path";
+
+// dist/risky/types.js
+var RISKY_ACTION_TYPES = [
+  "delete-files",
+  "discard-unsaved",
+  "rewrite-shared-history",
+  "delete-unmerged-work",
+  "wipe-data",
+  "read-credentials",
+  "publish",
+  "deploy",
+  "shrink-record",
+  "outside-own-copy"
+];
+function riskyTypeOrder(type) {
+  return RISKY_ACTION_TYPES.indexOf(type);
 }
-async function evaluateEdit(reply, readSeat) {
-  let input;
+var CHECKED_TOOLS = ["Bash", "Read", "Grep", "Write", "Edit", "MultiEdit", "NotebookEdit", "Agent"];
+var RECORDED_ONLY_TOOLS = ["PowerShell"];
+
+// dist/own-work.js
+var OWN_WORK_SHELL_TOOLS = ["Bash", "PowerShell"];
+var SHELL = new Set(OWN_WORK_SHELL_TOOLS);
+var MATCHED = /* @__PURE__ */ new Set([...CHECKED_TOOLS, ...RECORDED_ONLY_TOOLS]);
+function isOwnWorkShellTool(toolName) {
+  return typeof toolName === "string" && SHELL.has(toolName) && MATCHED.has(toolName);
+}
+function ownWorkFileName(sessionId) {
+  return `${OWN_WORK_PREFIX}${sessionId}${OWN_WORK_SUFFIX}`;
+}
+function ownWorkPath(sessionId, dir) {
+  if (typeof sessionId !== "string" || !livenessIdOk(sessionId))
+    return null;
+  return join10(dir ?? markerDir(), ownWorkFileName(sessionId));
+}
+function inputString2(input, key) {
+  if (typeof input !== "object" || input === null)
+    return null;
+  const value = input[key];
+  return typeof value === "string" && value !== "" ? value : null;
+}
+function ownShellLine(input, at) {
+  return { at: at.toISOString(), kind: "shell", agent: inputString2(input, "agent_id"), toolUse: inputString2(input, "tool_use_id") };
+}
+function ownEditLine(path, at) {
+  return { at: at.toISOString(), kind: "edit", path };
+}
+function append(sessionId, line2, dir) {
+  const path = ownWorkPath(sessionId, dir);
+  if (path === null)
+    return;
+  appendFileSync3(path, `${JSON.stringify(line2)}
+`, { mode: 384 });
+}
+function recordOwnShell(input, at, deps = {}) {
   try {
-    const raw = await readStdin();
-    input = JSON.parse(raw);
+    if (!isOwnWorkShellTool(inputString2(input, "tool_name")))
+      return;
+    append(inputString2(input, "session_id"), ownShellLine(input, at), deps.dir);
   } catch {
-    recordTimeEvent("edit", {});
-    return;
   }
-  recordTimeEvent("edit", input);
-  const toolName = input.tool_name ?? "";
-  if (!HANDLED_EDIT_TOOLS.has(toolName))
-    return;
-  const isNotebook = toolName === "NotebookEdit";
-  const absFilePath = isNotebook ? input.tool_input?.notebook_path : input.tool_input?.file_path;
-  if (!absFilePath || typeof absFilePath !== "string")
-    return;
-  const repoRootResult = getRepoRoot(process.cwd());
-  if (!repoRootResult.ok) {
-    if (firstNoRepoNoticeThisSession(process.cwd(), input.session_id)) {
-      reply.notice(noRepositoryText(repoRootResult));
+}
+function recordOwnEdit(input, filePath, deps = {}) {
+  try {
+    if (filePath === "")
+      return;
+    const base = inputString2(input, "cwd") ?? process.cwd();
+    const path = isAbsolute(filePath) ? filePath : resolve3(base, filePath);
+    append(inputString2(input, "session_id"), ownEditLine(path, (deps.now ?? (() => /* @__PURE__ */ new Date()))()), deps.dir);
+  } catch {
+  }
+}
+function parseOwnWork(text) {
+  const out = [];
+  for (const raw of text.split("\n")) {
+    if (raw === "")
+      continue;
+    try {
+      const o = JSON.parse(raw);
+      if (typeof o["at"] !== "string")
+        continue;
+      const nullable2 = (v) => v === null || typeof v === "string";
+      if (o["kind"] === "edit" && typeof o["path"] === "string")
+        out.push({ at: o["at"], kind: "edit", path: o["path"] });
+      else if (o["kind"] === "shell" && nullable2(o["agent"]) && nullable2(o["toolUse"])) {
+        out.push({ at: o["at"], kind: "shell", agent: o["agent"], toolUse: o["toolUse"] });
+      }
+    } catch {
     }
-    return;
   }
-  const repoRoot = repoRootResult.value;
-  const diffContent = isNotebook ? "" : getSingleFileDiff(absFilePath, repoRoot);
-  const { relative: pathRelative } = await import("node:path");
-  const relPath = pathRelative(repoRoot, absFilePath);
-  if (isInstallerOutput(relPath))
-    return;
-  const context = loadChangeSetContext(repoRoot);
-  const changeSet = buildChangeSet([{ path: relPath, diffContent }], {
-    ...context,
-    excerpts: readExcerptConfig()
-  });
-  const configResult = readConfig();
-  if (!configResult.config) {
-    await emitRunRecord({ runType: "hook", outcome: "unconfigured", changeSet });
-    if (!firstNoticeThisSession("credential-missing", repoRoot, input.session_id))
-      return;
-    emitNeverConfigured(UNCONFIGURED_EXIT_TOOL_USE, readNeverConfiguredReason(), pinnedEngagementId(projectFolder()));
-    return;
+  return out;
+}
+function readOwnWork(sessionId, dir) {
+  try {
+    const path = ownWorkPath(sessionId, dir);
+    if (path === null)
+      return [];
+    return parseOwnWork(readFileSync12(path, "utf-8"));
+  } catch {
+    return [];
   }
-  const { guardServiceUrl, guardServiceToken, guardEngagementId } = configResult.config;
-  const seatConfiguration = gatherSeatConfiguration(repoRoot, readSeat);
-  const evaluation = await evaluateWithRefresh({
-    guardServiceUrl,
-    token: guardServiceToken,
-    engagementId: guardEngagementId,
-    request: buildEvaluationRequest(guardEngagementId, changeSet, context, seatConfiguration),
-    warn: warnOnceThisSession("credential-renewed-for-this-run", repoRoot, input.session_id)
-  });
-  const clientResult = evaluation.result;
-  if (!clientResult.ok) {
-    const failure = classifyFailure(clientResult);
-    await emitRunRecord({
-      engagementId: guardEngagementId,
-      runType: "hook",
-      outcome: outcomeForClientFailure(clientResult.kind),
-      failureReason: failure.reason,
-      changeSet,
-      credential: evaluation.token,
-      credentialRefused: failure.kind === "credential"
-    });
-    if (failure.kind === "credential") {
-      if (!firstNoticeThisSession("credential-rejected", repoRoot, input.session_id))
-        return;
-      emitCredentialRejected(
-        failure.statusCode,
-        failure.message,
-        CREDENTIAL_REJECTED_EXIT_TOOL_USE,
-        // The remedy the renewal attempt earned: the sign-in when the account
-        // credential is the thing that was refused, and otherwise the plane's own
-        // sentence about why it would not mint.
-        evaluation.remedy
-      );
-      return;
+}
+function shellWindows(own, timeLines, sessionId, passAt) {
+  const out = [];
+  for (const line2 of own) {
+    if (line2.kind !== "shell")
+      continue;
+    const from = Date.parse(line2.at);
+    if (Number.isNaN(from))
+      continue;
+    let to = passAt;
+    for (const t of timeLines) {
+      if (t.session !== sessionId || t.agent !== line2.agent)
+        continue;
+      const isOwnLine = line2.toolUse !== null ? t.toolUse === line2.toolUse : t.at === line2.at;
+      if (isOwnLine)
+        continue;
+      const at = Date.parse(t.at);
+      if (Number.isNaN(at) || at < from)
+        continue;
+      if (at < to)
+        to = at;
     }
-    if (failure.kind === "contract") {
-      reply.notice(contractFaultText(failure.message));
-      return;
+    out.push({ from, to: Math.max(from, to) });
+  }
+  return out;
+}
+function realPathOf(path) {
+  const missing = [];
+  let at = resolve3(path);
+  for (; ; ) {
+    try {
+      return join10(realpathSync4.native(at), ...missing.reverse());
+    } catch {
+      const parent = dirname5(at);
+      if (parent === at)
+        return resolve3(path);
+      missing.push(basename(at));
+      at = parent;
     }
-    reply.notice(infraWarningText());
-    return;
   }
-  const telemetryConfig = readTelemetryConfig();
-  const run = buildGuardEvalRun({
-    engagementId: guardEngagementId,
+}
+function modifiedAt(path) {
+  try {
+    return lstatSync(path).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function ownEditedFiles(repoRoot, sessionId, deps = {}) {
+  const root = realPathOf(repoRoot);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line2 of readOwnWork(sessionId, deps.dir)) {
+    if (line2.kind !== "edit")
+      continue;
+    const abs = realPathOf(line2.path);
+    const rel = relative4(root, abs);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute(rel))
+      continue;
+    if (modifiedAt(abs) === null)
+      continue;
+    const posix3 = rel.split(sep2).join("/");
+    if (seen.has(posix3))
+      continue;
+    seen.add(posix3);
+    out.push(posix3);
+  }
+  return out;
+}
+function ownChangedFiles(repoRoot, files, sessionId, deps = {}) {
+  if (typeof sessionId !== "string" || ownWorkPath(sessionId, deps.dir) === null)
+    return [...files];
+  const own = readOwnWork(sessionId, deps.dir);
+  if (own.length === 0)
+    return [];
+  const edited = /* @__PURE__ */ new Set();
+  for (const line2 of own)
+    if (line2.kind === "edit")
+      edited.add(realPathOf(line2.path));
+  const hasShell = own.some((line2) => line2.kind === "shell");
+  const passAt = (deps.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+  const timeLines = hasShell ? readSessionTimeLines(sessionId, { env: deps.env, home: deps.home }) : [];
+  const windows = hasShell ? shellWindows(own, timeLines, sessionId, passAt) : [];
+  const inWindow = (mtimeMs) => {
+    if (mtimeMs === null)
+      return false;
+    const ms = Math.floor(mtimeMs);
+    return windows.some((w) => ms >= w.from && ms <= w.to);
+  };
+  const root = resolve3(repoRoot);
+  return files.filter((rel) => {
+    const abs = join10(root, rel);
+    if (edited.has(realPathOf(abs)))
+      return true;
+    if (windows.length === 0)
+      return false;
+    const mtime = modifiedAt(abs);
+    if (mtime !== null)
+      return inWindow(mtime);
+    return inWindow(modifiedAt(dirname5(abs)));
+  });
+}
+
+// dist/hooks/findings.js
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import { closeSync, existsSync as existsSync6, openSync, readFileSync as readFileSync13, renameSync as renameSync4, statSync as statSync3, unlinkSync as unlinkSync5, writeFileSync as writeFileSync6 } from "node:fs";
+function findingKey(firing) {
+  return createHash3("sha256").update(`${firing.guardId}
+${firing.path ?? ""}
+${firing.explanation}`).digest("hex");
+}
+function asFinding(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return null;
+  const o = raw;
+  const str = (k) => typeof o[k] === "string";
+  const bool = (k) => typeof o[k] === "boolean";
+  if (!str("key") || !str("folder") || !str("guardId") || !str("patternRef") || !str("explanation") || !str("foundAt"))
+    return null;
+  if (o["severity"] !== "info" && o["severity"] !== "warn")
+    return null;
+  if (!bool("announced") || !bool("delivered") || !bool("escalated"))
+    return null;
+  if (o["path"] !== void 0 && typeof o["path"] !== "string")
+    return null;
+  return {
+    key: o["key"],
+    folder: o["folder"],
+    guardId: o["guardId"],
+    patternRef: o["patternRef"],
+    severity: o["severity"],
+    explanation: o["explanation"],
+    ...typeof o["path"] === "string" ? { path: o["path"] } : {},
+    foundAt: o["foundAt"],
+    announced: o["announced"],
+    delivered: o["delivered"],
+    escalated: o["escalated"]
+  };
+}
+function emptyFindings(session) {
+  return { version: 1, session, findings: [] };
+}
+function readFindings(sessionId) {
+  const path = findingsPath(sessionId);
+  if (path === null)
+    return null;
+  const session = sessionId;
+  try {
+    const parsed = JSON.parse(readFileSync13(path, "utf-8"));
+    if (parsed["version"] !== 1 || !Array.isArray(parsed["findings"]))
+      return emptyFindings(session);
+    const findings = [];
+    for (const raw of parsed["findings"]) {
+      const f = asFinding(raw);
+      if (f !== null)
+        findings.push(f);
+    }
+    return { version: 1, session, findings };
+  } catch {
+    return emptyFindings(session);
+  }
+}
+function writeFindings(file2) {
+  const path = findingsPath(file2.session);
+  if (path === null)
+    return;
+  const temp = `${path.slice(0, -".json".length)}.${process.pid}.tmp.json`;
+  try {
+    writeFileSync6(temp, `${JSON.stringify(file2)}
+`, { mode: 384 });
+    renameSync4(temp, path);
+  } catch {
+    try {
+      unlinkSync5(temp);
+    } catch {
+    }
+  }
+}
+var FINDINGS_LOCK_WAIT_MS = 1e3;
+var FINDINGS_LOCK_STALE_MS = 5e3;
+function lockPathFor(path) {
+  return `${path.slice(0, -".json".length)}.lock.json`;
+}
+function pause(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function takeOverStaleLock(lock) {
+  const aside = `${lock}.${process.pid}.${randomUUID2()}.stale`;
+  try {
+    renameSync4(lock, aside);
+  } catch {
+    return false;
+  }
+  let staleIndeed = false;
+  try {
+    staleIndeed = Date.now() - statSync3(aside).mtimeMs > FINDINGS_LOCK_STALE_MS;
+  } catch {
+    staleIndeed = false;
+  }
+  if (!staleIndeed) {
+    try {
+      renameSync4(aside, lock);
+    } catch {
+      try {
+        unlinkSync5(aside);
+      } catch {
+      }
+    }
+    return false;
+  }
+  try {
+    unlinkSync5(aside);
+  } catch {
+  }
+  return true;
+}
+function withFindingsLock(sessionId, body, waitMs = FINDINGS_LOCK_WAIT_MS) {
+  const path = findingsPath(sessionId);
+  if (path === null)
+    return void 0;
+  const lock = lockPathFor(path);
+  const deadline = Date.now() + waitMs;
+  for (; ; ) {
+    try {
+      closeSync(openSync(lock, "wx", 384));
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        return void 0;
+      let stale = false;
+      try {
+        stale = Date.now() - statSync3(lock).mtimeMs > FINDINGS_LOCK_STALE_MS;
+      } catch {
+        continue;
+      }
+      if (stale && takeOverStaleLock(lock))
+        continue;
+      if (Date.now() >= deadline)
+        return void 0;
+      pause(10);
+    }
+  }
+  try {
+    return body();
+  } finally {
+    try {
+      unlinkSync5(lock);
+    } catch {
+    }
+  }
+}
+function takeUndelivered(file2, folder) {
+  const taken = [];
+  const findings = file2.findings.map((f) => {
+    if (f.delivered || folder !== null && f.folder !== folder)
+      return f;
+    taken.push(f);
+    return { ...f, delivered: true };
+  });
+  return { file: { ...file2, findings }, taken };
+}
+function deliverFindings(sessionId, folder) {
+  const path = findingsPath(sessionId);
+  if (path === null || !existsSync6(path))
+    return [];
+  try {
+    const taken = withFindingsLock(sessionId, () => {
+      const before = readFindings(sessionId);
+      if (before === null)
+        return [];
+      const { file: file2, taken: given } = takeUndelivered(before, folder);
+      if (given.length > 0)
+        writeFindings(file2);
+      return given;
+    });
+    return taken ?? [];
+  } catch {
+    return [];
+  }
+}
+function turnEndBookkeeping(file2, folder, outcome, topLevel, now) {
+  const recorded = [...file2.findings];
+  const firing = /* @__PURE__ */ new Map();
+  const notRun = new Set(outcome.kind === "evaluated" ? outcome.notRun : []);
+  const observed = (f) => f.folder === folder && !notRun.has(f.patternRef);
+  if (outcome.kind === "evaluated") {
+    for (const g of outcome.fired) {
+      if (g.severity === "block")
+        continue;
+      const key = findingKey(g);
+      if (!firing.has(key))
+        firing.set(key, g);
+    }
+  }
+  const removed = [];
+  const kept = [];
+  for (const f of recorded) {
+    const closes = observed(f) && (outcome.kind === "no-own-changes" || outcome.kind === "evaluated" && !firing.has(f.key));
+    (closes ? removed : kept).push(f);
+  }
+  const known = new Set(kept.filter((f) => f.folder === folder).map((f) => f.key));
+  for (const [key, g] of firing) {
+    if (known.has(key))
+      continue;
+    kept.push({
+      key,
+      folder,
+      guardId: g.guardId,
+      patternRef: g.patternRef,
+      severity: g.severity,
+      explanation: g.explanation,
+      ...g.path !== void 0 ? { path: g.path } : {},
+      foundAt: now.toISOString(),
+      announced: false,
+      delivered: false,
+      escalated: false
+    });
+  }
+  if (!topLevel) {
+    return { file: { ...file2, findings: kept }, news: { fixed: 0, allFixed: false, found: 0, stillOpen: [] } };
+  }
+  const fixed = removed.filter((f) => f.announced).length;
+  const allFixed = !kept.some((f) => f.announced);
+  let found2 = 0;
+  const stillOpen = [];
+  const next = kept.map((f) => {
+    if (!f.announced) {
+      found2 += 1;
+      return { ...f, announced: true };
+    }
+    if (f.delivered && !f.escalated && observed(f)) {
+      stillOpen.push(f.explanation);
+      return { ...f, escalated: true };
+    }
+    return f;
+  });
+  return { file: { ...file2, findings: next }, news: { fixed, allFixed, found: found2, stillOpen } };
+}
+function blockingExplanations(fired) {
+  const blocks = fired.filter((g) => g.severity === "block");
+  return (blocks.length > 0 ? blocks : fired).map((g) => g.explanation);
+}
+
+// dist/hooks/finding-lines.js
+function bullets(explanations) {
+  return explanations.map((e) => `- ${e}`).join("\n");
+}
+function distinctBullets(explanations) {
+  return bullets([...new Set(explanations)]);
+}
+function foundLine(count) {
+  return count === 1 ? "Halfcycle found 1 small thing to fix in this turn's work. The agent gets the details with your next message and will fix it; there is nothing for you to do." : `Halfcycle found ${count} small things to fix in this turn's work. The agent gets the details with your next message and will fix them; there is nothing for you to do.`;
+}
+function fixedLine(count, all) {
+  if (all)
+    return "Halfcycle: everything it found earlier is now fixed.";
+  return count === 1 ? "Halfcycle: 1 of the things it found earlier is now fixed." : `Halfcycle: ${count} of the things it found earlier are now fixed.`;
+}
+function stillOpenMessage(explanations) {
+  const n = explanations.length;
+  const head = n === 1 ? "Halfcycle: 1 thing it found is still not fixed after the agent's last turn." : `Halfcycle: ${n} things it found are still not fixed after the agent's last turn.`;
+  const tail = n === 1 ? "Ask the agent to fix it, or tell it to leave it as it is if that is what you want." : "Ask the agent to fix them, or tell it to leave them as they are if that is what you want.";
+  return `${head}
+${bullets(explanations)}
+${tail}`;
+}
+function stoppedMessage(explanations) {
+  return [
+    "Halfcycle stopped this step because something in the agent's work has to be fixed first:",
+    distinctBullets(explanations),
+    "The agent has the details and is fixing it now. If it is still stopped after the agent's next try, ask the agent what is in the way."
+  ].join("\n");
+}
+function couldNotFixMessage(explanations) {
+  return [
+    "Halfcycle: the agent could not fix what stopped its work:",
+    distinctBullets(explanations),
+    "Ask the agent what is in the way, or tell it how you want this handled."
+  ].join("\n");
+}
+function notRunMessage(reasons) {
+  if (reasons.length === 0)
+    return "";
+  const head = reasons.length === 1 ? "Halfcycle: 1 check could not run on this change." : `Halfcycle: ${reasons.length} checks could not run on this change.`;
+  return `${head}
+${distinctBullets(reasons)}`;
+}
+function blockReason(explanations) {
+  return `Halfcycle stopped this step. Fix each of these before you carry on:
+${distinctBullets(explanations)}`;
+}
+function detailsBlock(findings, projectFolder2) {
+  const lines2 = findings.map((f) => {
+    const where = f.folder === projectFolder2 ? f.path : f.path === void 0 ? f.folder : `${f.folder}/${f.path}`;
+    const at = where === void 0 ? "" : ` in ${where}`;
+    return `  [${f.severity.toUpperCase()}] ${f.patternRef}${at}: ${f.explanation}`;
+  });
+  return [
+    "Halfcycle's checks found these in this session's own changes at the end of an earlier turn. Fix each one now, as part of this turn, before anything else; then carry on with what the person asks. Do not ask the person whether to fix them, and do not end your turn with a question before they are fixed. If the person later tells you to keep one, that is their call. When you mention them to the person, use plain words, not the labels in brackets.",
+    ...lines2
+  ].join("\n");
+}
+function turnEndMessage(news) {
+  const parts = [];
+  if (news.fixed > 0)
+    parts.push(fixedLine(news.fixed, news.allFixed));
+  if (news.found > 0)
+    parts.push(foundLine(news.found));
+  if (news.stillOpen.length > 0)
+    parts.push(stillOpenMessage(news.stillOpen));
+  return parts.length === 0 ? null : parts.join("\n");
+}
+
+// dist/hooks/post-tool-use.js
+var HANDLED_EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+async function runPostToolUse(readSeat = readSeatConfiguration) {
+  const reply = hookReply("PostToolUse");
+  const at = { session: void 0, folder: null };
+  await evaluateEdit(reply, readSeat, at);
+  handOverAtEdit(reply, at);
+  reply.flush();
+}
+function handOverAtEdit(reply, at) {
+  if (at.folder === null)
+    return;
+  const code = process.exitCode;
+  if (code !== void 0 && code !== null && Number(code) !== 0)
+    return;
+  const given = deliverFindings(at.session, at.folder);
+  if (given.length === 0)
+    return;
+  reply.agentContext(detailsBlock(given, realPathOf(projectFolder())));
+}
+async function evaluateEdit(reply, readSeat, at) {
+  let input;
+  try {
+    const raw = await readStdin();
+    input = JSON.parse(raw);
+  } catch {
+    recordTimeEvent("edit", {});
+    return;
+  }
+  recordTimeEvent("edit", input);
+  const toolName = input.tool_name ?? "";
+  if (!HANDLED_EDIT_TOOLS.has(toolName))
+    return;
+  const isNotebook = toolName === "NotebookEdit";
+  const absFilePath = isNotebook ? input.tool_input?.notebook_path : input.tool_input?.file_path;
+  if (!absFilePath || typeof absFilePath !== "string")
+    return;
+  recordOwnEdit(input, absFilePath);
+  const repoRootResult = getRepoRoot(process.cwd());
+  if (!repoRootResult.ok) {
+    if (firstNoRepoNoticeThisSession(process.cwd(), input.session_id)) {
+      reply.notice(noRepositoryText(repoRootResult));
+    }
+    return;
+  }
+  const repoRoot = repoRootResult.value;
+  at.session = input.session_id;
+  at.folder = realPathOf(repoRoot);
+  const diffContent = isNotebook ? "" : getSingleFileDiff(absFilePath, repoRoot);
+  const { relative: pathRelative } = await import("node:path");
+  const relPath = pathRelative(repoRoot, absFilePath);
+  if (isInstallerOutput(relPath))
+    return;
+  const context = loadChangeSetContext(repoRoot);
+  const changeSet = buildChangeSet([{ path: relPath, diffContent }], {
+    ...context,
+    excerpts: readExcerptConfig()
+  });
+  const configResult = readConfig();
+  if (!configResult.config) {
+    await emitRunRecord({ runType: "hook", outcome: "unconfigured", changeSet });
+    if (!firstNoticeThisSession("credential-missing", repoRoot, input.session_id))
+      return;
+    emitNeverConfigured(UNCONFIGURED_EXIT_TOOL_USE, readNeverConfiguredReason(), pinnedEngagementId(projectFolder()));
+    return;
+  }
+  const { guardServiceUrl, guardServiceToken, guardEngagementId } = configResult.config;
+  const seatConfiguration = gatherSeatConfiguration(repoRoot, readSeat);
+  const evaluation = await evaluateWithRefresh({
+    guardServiceUrl,
+    token: guardServiceToken,
+    engagementId: guardEngagementId,
+    request: buildEvaluationRequest(guardEngagementId, changeSet, context, seatConfiguration),
+    warn: warnOnceThisSession("credential-renewed-for-this-run", repoRoot, input.session_id)
+  });
+  const clientResult = evaluation.result;
+  if (!clientResult.ok) {
+    const failure = classifyFailure(clientResult);
+    await emitRunRecord({
+      engagementId: guardEngagementId,
+      runType: "hook",
+      outcome: outcomeForClientFailure(clientResult.kind),
+      failureReason: failure.reason,
+      changeSet,
+      credential: evaluation.token,
+      credentialRefused: failure.kind === "credential"
+    });
+    if (failure.kind === "credential") {
+      if (!firstNoticeThisSession("credential-rejected", repoRoot, input.session_id))
+        return;
+      emitCredentialRejected(
+        failure.statusCode,
+        failure.message,
+        CREDENTIAL_REJECTED_EXIT_TOOL_USE,
+        // The remedy the renewal attempt earned: the sign-in when the account
+        // credential is the thing that was refused, and otherwise the plane's own
+        // sentence about why it would not mint.
+        evaluation.remedy
+      );
+      return;
+    }
+    if (failure.kind === "contract") {
+      reply.notice(contractFaultText(failure.message));
+      return;
+    }
+    reply.notice(infraWarningText());
+    return;
+  }
+  const telemetryConfig = readTelemetryConfig();
+  const run = buildGuardEvalRun({
+    engagementId: guardEngagementId,
     runType: "hook",
     // The phase this run belongs to, as the client named it — it names the
     // guard-eval log file the run is appended to. Absent → the run is unphased.
@@ -22597,10 +23551,10 @@ ${notRun}` : "";
     return;
   }
   if (envelope.blocking) {
-    const guardLines = envelope.guardsFired.map((g) => `  [${g.severity.toUpperCase()}] ${g.patternRef}: ${g.explanation}`).join("\n");
-    const reason = `Guard blocked: ${envelope.explanation}
-${guardLines}${notRunBlock}`;
-    reply.block(reason);
+    const personNotRun = notRunMessage((envelope.notRun ?? []).map((n) => n.reason));
+    const reason = `${blockReason(envelope.guardsFired.map((g) => g.explanation))}${personNotRun ? `
+${personNotRun}` : ""}`;
+    reply.block(reason, stoppedMessage(blockingExplanations(envelope.guardsFired)));
   } else {
     const guardLines = envelope.guardsFired.map((g) => `  [${g.severity.toUpperCase()}] ${g.patternRef}: ${g.explanation}`).join("\n");
     reply.notice(`[Halfcycle] Guard warning: ${envelope.explanation}
@@ -22608,17 +23562,17 @@ ${guardLines}${notRunBlock}`);
   }
 }
 function readStdin() {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve6(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("end", () => resolve8(Buffer.concat(chunks).toString("utf-8")));
     process.stdin.on("error", reject);
   });
 }
 
 // dist/liveness.js
-import { closeSync, mkdtempSync, openSync, readdirSync as readdirSync5, readFileSync as readFileSync12, renameSync as renameSync4, rmSync, statSync as statSync3, unlinkSync as unlinkSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join10 } from "node:path";
+import { closeSync as closeSync2, mkdtempSync, openSync as openSync2, readdirSync as readdirSync5, readFileSync as readFileSync14, renameSync as renameSync5, rmSync, statSync as statSync4, unlinkSync as unlinkSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join11 } from "node:path";
 var LIVE_WINDOW_MS = 10 * 60 * 1e3;
 function field(input, key) {
   if (typeof input !== "object" || input === null)
@@ -22627,10 +23581,10 @@ function field(input, key) {
   return typeof v === "string" && v !== "" ? v : null;
 }
 function indexEntry(dir, sessionId, name) {
-  const folder = join10(dir, livenessIndexDirName(sessionId));
+  const folder = join11(dir, livenessIndexDirName(sessionId));
   for (let attempt2 = 0; attempt2 < 3; attempt2++) {
     try {
-      closeSync(openSync(join10(folder, name), "a", 384));
+      closeSync2(openSync2(join11(folder, name), "a", 384));
       return true;
     } catch (err) {
       if (err.code !== "ENOENT")
@@ -22641,10 +23595,10 @@ function indexEntry(dir, sessionId, name) {
       tmp = mkdtempSync(`${folder}.`);
       for (const existing of readdirSync5(dir)) {
         if (parseLivenessFileName(existing)?.sessionId === sessionId)
-          closeSync(openSync(join10(tmp, existing), "a", 384));
+          closeSync2(openSync2(join11(tmp, existing), "a", 384));
       }
-      closeSync(openSync(join10(tmp, name), "a", 384));
-      renameSync4(tmp, folder);
+      closeSync2(openSync2(join11(tmp, name), "a", 384));
+      renameSync5(tmp, folder);
       return true;
     } catch {
       if (tmp !== null)
@@ -22669,18 +23623,18 @@ function recordLiveness(input, deps = {}) {
     const name = livenessFileName(livenessKey(copy?.common ?? null), sessionId, agentId);
     if (!indexEntry(dir, sessionId, name))
       return null;
-    const path = join10(dir, name);
+    const path = join11(dir, name);
     const text = `${cwd}
 ${copy?.top ?? ""}
 `;
     try {
-      writeFileSync6(path, text, { encoding: "utf-8", flag: "wx", mode: 384 });
+      writeFileSync7(path, text, { encoding: "utf-8", flag: "wx", mode: 384 });
       return { firstSeen: true };
     } catch (err) {
       if (err.code !== "EEXIST")
         return null;
     }
-    writeFileSync6(path, text, { encoding: "utf-8", mode: 384 });
+    writeFileSync7(path, text, { encoding: "utf-8", mode: 384 });
     return { firstSeen: false };
   } catch {
     return null;
@@ -22699,7 +23653,7 @@ function clearLiveness(input, deps = {}) {
       if (p === null || p.sessionId !== sessionId || p.agentId !== agentId)
         continue;
       try {
-        unlinkSync5(join10(dir, name));
+        unlinkSync6(join11(dir, name));
         removed += 1;
       } catch {
       }
@@ -22712,7 +23666,7 @@ function clearLiveness(input, deps = {}) {
 }
 function topOf(path) {
   try {
-    const top = readFileSync12(path, "utf-8").split("\n")[1] ?? "";
+    const top = readFileSync14(path, "utf-8").split("\n")[1] ?? "";
     return top === "" ? null : top;
   } catch {
     return null;
@@ -22734,10 +23688,10 @@ function readLiveness(sessionId, cwd, deps = {}) {
       const p = parseLivenessFileName(name);
       if (p === null || p.key !== key || p.sessionId !== sessionId)
         continue;
-      const full = join10(dir, name);
+      const full = join11(dir, name);
       let seenAt;
       try {
-        seenAt = statSync3(full).mtimeMs;
+        seenAt = statSync4(full).mtimeMs;
       } catch {
         continue;
       }
@@ -22775,17 +23729,17 @@ function runsBesideOtherWork(toolInput, record2) {
 }
 
 // dist/pace-hook.js
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync16, renameSync as renameSync8, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync18, renameSync as renameSync9, unlinkSync as unlinkSync8, writeFileSync as writeFileSync11 } from "node:fs";
 import nodePath4 from "node:path";
 
 // dist/pace-verb.js
-import { mkdirSync as mkdirSync6, readdirSync as readdirSync7, readFileSync as readFileSync15, renameSync as renameSync7, statSync as statSync5, writeFileSync as writeFileSync9 } from "node:fs";
+import { mkdirSync as mkdirSync6, readdirSync as readdirSync7, readFileSync as readFileSync17, renameSync as renameSync8, statSync as statSync6, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import nodePath3 from "node:path";
 
 // dist/pacing.js
-import { createHash as createHash3 } from "node:crypto";
-import { closeSync as closeSync2, mkdirSync as mkdirSync4, openSync as openSync2, readdirSync as readdirSync6, readFileSync as readFileSync13, readSync, realpathSync as realpathSync4, renameSync as renameSync5, statSync as statSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { closeSync as closeSync3, mkdirSync as mkdirSync4, openSync as openSync3, readdirSync as readdirSync6, readFileSync as readFileSync15, readSync, realpathSync as realpathSync5, renameSync as renameSync6, statSync as statSync5, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import nodePath from "node:path";
 var DEFAULT_CONFIG_FOLDER_NAME = ".claude";
@@ -22834,7 +23788,7 @@ function pacingDir(home) {
 }
 function readJsonObject(path) {
   try {
-    const v = JSON.parse(readFileSync13(path, "utf-8"));
+    const v = JSON.parse(readFileSync15(path, "utf-8"));
     return typeof v === "object" && v !== null && !Array.isArray(v) ? v : null;
   } catch {
     return null;
@@ -22842,9 +23796,9 @@ function readJsonObject(path) {
 }
 function writeJsonWhole(path, value) {
   mkdirSync4(nodePath.dirname(path), { recursive: true, mode: 448 });
-  const tmp = `${path}.${String(process.pid)}.${createHash3("sha1").update(String(Math.random())).digest("hex").slice(0, 8)}.tmp`;
-  writeFileSync7(tmp, JSON.stringify(value), { mode: 384 });
-  renameSync5(tmp, path);
+  const tmp = `${path}.${String(process.pid)}.${createHash4("sha1").update(String(Math.random())).digest("hex").slice(0, 8)}.tmp`;
+  writeFileSync8(tmp, JSON.stringify(value), { mode: 384 });
+  renameSync6(tmp, path);
 }
 function writeAccountEntry(path, key, entry) {
   const current = readJsonObject(path);
@@ -22864,6 +23818,62 @@ function accountKeysOf(path) {
   const accounts = current?.["accounts"];
   return typeof accounts === "object" && accounts !== null && !Array.isArray(accounts) ? Object.keys(accounts) : [];
 }
+var PACE_STATE_FILENAME = "state.json";
+function paceStateEntryOf(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v))
+    return null;
+  const o = v;
+  const pace = paceStateSchema.safeParse(o["pace"]);
+  const kind = o["windowKind"] === null ? null : paceWindowKindSchema.safeParse(o["windowKind"]);
+  const allowance = o["allowance"];
+  const number4 = o["number"];
+  const until = o["until"];
+  const at = o["at"];
+  if (!pace.success || kind !== null && !kind.success)
+    return null;
+  if (typeof allowance !== "number" || !Number.isInteger(allowance) || allowance < 0)
+    return null;
+  if (typeof number4 !== "number" || !Number.isInteger(number4) || number4 < 1 || number4 > PACE_AGENTS_MAX)
+    return null;
+  if (until !== null && (typeof until !== "string" || Number.isNaN(Date.parse(until))))
+    return null;
+  if (typeof at !== "string" || Number.isNaN(Date.parse(at)))
+    return null;
+  return { pace: pace.data, allowance, number: number4, windowKind: kind === null ? null : kind.data, until, at };
+}
+function rememberedBasisOf(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v))
+    return null;
+  const o = v;
+  const phase = o["phase"] === null ? null : phaseNameSchema.safeParse(o["phase"]);
+  const plan = o["claudePlan"] === null ? null : claudePlanSchema.safeParse(o["claudePlan"]);
+  const keep = keepFreePercentSchema.safeParse(o["keepFreePercent"]);
+  if (phase !== null && !phase.success || plan !== null && !plan.success || !keep.success)
+    return null;
+  return { phase: phase === null ? null : phase.data, claudePlan: plan === null ? null : plan.data, keepFreePercent: keep.data };
+}
+function readPaceStateFile(dir) {
+  const o = readJsonObject(nodePath.join(dir, PACE_STATE_FILENAME));
+  const accounts = {};
+  const rawAccounts = o?.["accounts"];
+  if (typeof rawAccounts === "object" && rawAccounts !== null && !Array.isArray(rawAccounts)) {
+    for (const [key, v] of Object.entries(rawAccounts)) {
+      const e = paceStateEntryOf(v);
+      if (e !== null)
+        accounts[key] = e;
+    }
+  }
+  return { accounts, basis: rememberedBasisOf(o?.["basis"]) };
+}
+function writePaceState(dir, key, entry, basis) {
+  const current = readPaceStateFile(dir);
+  const accounts = { ...current.accounts };
+  if (entry === null)
+    delete accounts[key];
+  else
+    accounts[key] = entry;
+  writeJsonWhole(nodePath.join(dir, PACE_STATE_FILENAME), { accounts, basis: basis ?? current.basis });
+}
 function recordFactsOf(o) {
   if (o["type"] !== "assistant")
     return null;
@@ -22979,7 +23989,7 @@ var NEWLINE = 10;
 var ASSISTANT = Buffer.from('"assistant"');
 var READ_CHUNK = 8 * 1024 * 1024;
 function readWholeLines(path, from, size, onLine) {
-  const fd = openSync2(path, "r");
+  const fd = openSync3(path, "r");
   try {
     let pos = from;
     let carry = Buffer.alloc(0);
@@ -23007,11 +24017,11 @@ function readWholeLines(path, from, size, onLine) {
     }
     return consumed;
   } finally {
-    closeSync2(fd);
+    closeSync3(fd);
   }
 }
 function hashId(id) {
-  return createHash3("sha1").update(id).digest("base64url").slice(0, 16);
+  return createHash4("sha1").update(id).digest("base64url").slice(0, 16);
 }
 function scanRecords(key, deps = {}) {
   const nowMs = (deps.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
@@ -23036,7 +24046,7 @@ function scanRecords(key, deps = {}) {
     let size;
     let mtimeSec;
     try {
-      const st = statSync4(file2.path);
+      const st = statSync5(file2.path);
       size = st.size;
       mtimeSec = Math.floor(st.mtimeMs / 1e3);
     } catch {
@@ -23159,7 +24169,7 @@ function tokensBetween(minutes, fromSec, toSec) {
 }
 function resolvedRecords(key, path) {
   try {
-    return realpathSync4(recordsFolderOf(key, path));
+    return realpathSync5(recordsFolderOf(key, path));
   } catch {
     return null;
   }
@@ -23172,7 +24182,7 @@ function timeLogTranscripts(home) {
       continue;
     let text;
     try {
-      text = readFileSync13(nodePath.join(engagements, e.name, TIME_LOG_DIR_NAME, TIME_LOG_FILENAME), "utf-8");
+      text = readFileSync15(nodePath.join(engagements, e.name, TIME_LOG_DIR_NAME, TIME_LOG_FILENAME), "utf-8");
     } catch {
       continue;
     }
@@ -23332,7 +24342,7 @@ function knownWindowOf(learned, reported, now) {
 
 // dist/scan-lock.js
 import { spawn } from "node:child_process";
-import { linkSync, mkdirSync as mkdirSync5, readFileSync as readFileSync14, renameSync as renameSync6, unlinkSync as unlinkSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { linkSync, mkdirSync as mkdirSync5, readFileSync as readFileSync16, renameSync as renameSync7, unlinkSync as unlinkSync7, writeFileSync as writeFileSync9 } from "node:fs";
 import nodePath2 from "node:path";
 var SCAN_LOCK_FILENAME = "scan.lock";
 var SCAN_LOCK_STALE_MS = 15 * 60 * 1e3;
@@ -23343,7 +24353,7 @@ function scanLockPath(home) {
 function readLockBody(path) {
   let text;
   try {
-    text = readFileSync14(path, "utf-8");
+    text = readFileSync16(path, "utf-8");
   } catch (err) {
     return err.code === "ENOENT" ? "missing" : null;
   }
@@ -23373,7 +24383,7 @@ function isStale(body, staleMs, deps) {
   return !(deps.alive ?? processAlive)(body.pid);
 }
 function writeLock(path, pid, deps, flag) {
-  writeFileSync8(path, JSON.stringify({ pid, at: (deps.clock ?? Date.now)() }), { flag, mode: 384 });
+  writeFileSync9(path, JSON.stringify({ pid, at: (deps.clock ?? Date.now)() }), { flag, mode: 384 });
 }
 function tryTakeScanLock(deps = {}) {
   return tryTakeLockFile(scanLockPath(deps.home), SCAN_LOCK_STALE_MS, deps);
@@ -23400,7 +24410,7 @@ function tryTakeLockFile(path, staleMs, deps = {}) {
       return false;
     const aside = `${path}.${String(pid)}.${String((deps.clock ?? Date.now)())}.stale`;
     try {
-      renameSync6(path, aside);
+      renameSync7(path, aside);
     } catch {
       continue;
     }
@@ -23412,13 +24422,13 @@ function tryTakeLockFile(path, staleMs, deps = {}) {
       } catch {
       }
       try {
-        unlinkSync6(aside);
+        unlinkSync7(aside);
       } catch {
       }
       return false;
     }
     try {
-      unlinkSync6(aside);
+      unlinkSync7(aside);
     } catch {
     }
   }
@@ -23429,7 +24439,7 @@ function releaseLockFile(path, pid = process.pid) {
   if (body === "missing" || body === null || body.pid !== pid)
     return;
   try {
-    unlinkSync6(path);
+    unlinkSync7(path);
   } catch {
   }
 }
@@ -23620,7 +24630,7 @@ function readBuildNumber(engagementId, home) {
   if (dir === null)
     return null;
   try {
-    const v = JSON.parse(readFileSync15(nodePath3.join(dir, BUILD_NUMBER_FILENAME), "utf-8"));
+    const v = JSON.parse(readFileSync17(nodePath3.join(dir, BUILD_NUMBER_FILENAME), "utf-8"));
     const n = v["number"];
     if (typeof v["phase"] === "string" && typeof n === "number" && Number.isInteger(n) && n >= 1 && n <= PACE_AGENTS_MAX && typeof v["namedByOwner"] === "boolean") {
       return { phase: v["phase"], number: n, namedByOwner: v["namedByOwner"] };
@@ -23640,12 +24650,12 @@ function writeBuildNumber(engagementId, value, home) {
   mkdirSync6(dir, { recursive: true, mode: 448 });
   const path = nodePath3.join(dir, BUILD_NUMBER_FILENAME);
   const tmp = `${path}.${String(process.pid)}.tmp`;
-  writeFileSync9(tmp, JSON.stringify(value), { mode: 384 });
-  renameSync7(tmp, path);
+  writeFileSync10(tmp, JSON.stringify(value), { mode: 384 });
+  renameSync8(tmp, path);
 }
 function readRememberedClaudePlan(home) {
   try {
-    const parsed = claudePlanRequestSchema.safeParse(JSON.parse(readFileSync15(nodePath3.join(home ?? homedir6(), HALFCYCLE_DIR_NAME, REMEMBERED_CLAUDE_PLAN_FILENAME), "utf-8")));
+    const parsed = claudePlanRequestSchema.safeParse(JSON.parse(readFileSync17(nodePath3.join(home ?? homedir6(), HALFCYCLE_DIR_NAME, REMEMBERED_CLAUDE_PLAN_FILENAME), "utf-8")));
     return parsed.success ? parsed.data.claudePlan : null;
   } catch {
     return null;
@@ -23665,7 +24675,7 @@ function liveSubAgentsIn(cwd, deps = {}) {
       if (p === null || p.key !== key || p.agentId === null)
         continue;
       try {
-        if (now - statSync5(nodePath3.join(dir, name)).mtimeMs <= LIVE_WINDOW_MS)
+        if (now - statSync6(nodePath3.join(dir, name)).mtimeMs <= LIVE_WINDOW_MS)
           n += 1;
       } catch {
       }
@@ -23824,6 +24834,23 @@ async function runPaceVerb(args2, deps = {}) {
       number4 = stored?.number ?? Math.min(claudePlanOf(claudePlan).startingAgents, PACE_AGENTS_MAX);
     }
     const decision = paceOf({ number: number4, keepFreePercent, learned, reported, now });
+    if (basis !== null) {
+      const dir = enginePacingDir(engagementId, deps.home);
+      if (dir !== null) {
+        const entry = {
+          pace: decision.pace,
+          allowance: decision.allowance,
+          number: number4,
+          windowKind: decision.windowKind,
+          until: decision.until === null ? null : decision.until.toISOString(),
+          at: now.toISOString()
+        };
+        try {
+          writePaceState(dir, key, entry, { phase: basis.phase, claudePlan: basis.claudePlan, keepFreePercent });
+        } catch {
+        }
+      }
+    }
     const live = liveSubAgentsIn(deps.cwd ?? process.cwd(), deps.live);
     const result = {
       outcome: "paced",
@@ -23844,11 +24871,10 @@ async function runPaceVerb(args2, deps = {}) {
 var PACE_HELD_TOOL = "Agent";
 var PACE_STEP_MIN_INTERVAL_MS = OBSERVE_MIN_INTERVAL_MS;
 var PACE_STATE_FRESH_MS = 10 * 60 * 1e3;
-var PACE_PENDING_START_MS = 60 * 1e3;
+var PACE_PENDING_START_MS = 15 * 1e3;
 var PACE_STARTS_LOCK_STALE_MS = 5 * 1e3;
 var PACE_STARTS_LOCK_GIVE_UP_MS = 50;
 var STARTS_LOCK_POLL_MS = 2;
-var PACE_STATE_FILENAME = "state.json";
 var PACE_STARTS_FILENAME = "starts.json";
 var PACE_STARTS_LOCK_FILENAME = "starts.lock";
 function objectOf(v) {
@@ -23856,7 +24882,7 @@ function objectOf(v) {
 }
 function readJson(path) {
   try {
-    return objectOf(JSON.parse(readFileSync16(path, "utf-8")));
+    return objectOf(JSON.parse(readFileSync18(path, "utf-8")));
   } catch {
     return null;
   }
@@ -23865,68 +24891,16 @@ function writeJsonWhole2(path, value) {
   mkdirSync7(nodePath4.dirname(path), { recursive: true, mode: 448 });
   const tmp = `${path}.${String(process.pid)}.${Math.random().toString(36).slice(2, 10)}.tmp`;
   try {
-    writeFileSync10(tmp, JSON.stringify(value), { mode: 384 });
-    renameSync8(tmp, path);
+    writeFileSync11(tmp, JSON.stringify(value), { mode: 384 });
+    renameSync9(tmp, path);
   } catch (err) {
     try {
-      unlinkSync7(tmp);
+      unlinkSync8(tmp);
     } catch {
     }
     throw err;
   }
 }
-function entryOf(v) {
-  const o = objectOf(v);
-  if (o === null)
-    return null;
-  const pace = paceStateSchema.safeParse(o["pace"]);
-  const kind = o["windowKind"] === null ? null : paceWindowKindSchema.safeParse(o["windowKind"]);
-  const allowance = o["allowance"];
-  const number4 = o["number"];
-  const until = o["until"];
-  const at = o["at"];
-  if (!pace.success || kind !== null && !kind.success)
-    return null;
-  if (typeof allowance !== "number" || !Number.isInteger(allowance) || allowance < 0)
-    return null;
-  if (typeof number4 !== "number" || !Number.isInteger(number4) || number4 < 1 || number4 > PACE_AGENTS_MAX)
-    return null;
-  if (until !== null && (typeof until !== "string" || Number.isNaN(Date.parse(until))))
-    return null;
-  if (typeof at !== "string" || Number.isNaN(Date.parse(at)))
-    return null;
-  return { pace: pace.data, allowance, number: number4, windowKind: kind === null ? null : kind.data, until, at };
-}
-function rememberedBasisOf(v) {
-  const o = objectOf(v);
-  if (o === null)
-    return null;
-  const phase = o["phase"] === null ? null : phaseNameSchema.safeParse(o["phase"]);
-  const plan = o["claudePlan"] === null ? null : claudePlanSchema.safeParse(o["claudePlan"]);
-  const keep = keepFreePercentSchema.safeParse(o["keepFreePercent"]);
-  if (phase !== null && !phase.success || plan !== null && !plan.success || !keep.success)
-    return null;
-  return { phase: phase === null ? null : phase.data, claudePlan: plan === null ? null : plan.data, keepFreePercent: keep.data };
-}
-function readPaceStateFile(dir) {
-  const o = readJson(nodePath4.join(dir, PACE_STATE_FILENAME));
-  const accounts = {};
-  for (const [key, v] of Object.entries(objectOf(o?.["accounts"]) ?? {})) {
-    const e = entryOf(v);
-    if (e !== null)
-      accounts[key] = e;
-  }
-  return { accounts, basis: rememberedBasisOf(o?.["basis"]) };
-}
-function writePaceState(dir, key, entry, basis) {
-  const current = readPaceStateFile(dir);
-  const accounts = { ...current.accounts };
-  if (entry === null)
-    delete accounts[key];
-  else
-    accounts[key] = entry;
-  writeJsonWhole2(nodePath4.join(dir, PACE_STATE_FILENAME), { accounts, basis: basis ?? current.basis });
-}
 function field2(input, key) {
   const v = objectOf(input)?.[key];
   return typeof v === "string" && v !== "" ? v : null;
@@ -23934,12 +24908,14 @@ function field2(input, key) {
 function shownAs(pace, windowKind, allowance) {
   return pace === "full" ? "full" : `${pace}:${windowKind ?? ""}:${pace === "slowing" ? String(allowance) : ""}`;
 }
-function paceChangeText(before, after, working, now) {
+function paceChangeText(before, after, working, now, keepFreePercent) {
   const was = before === null ? "full" : shownAs(before.pace, before.windowKind, before.allowance);
   const is = shownAs(after.pace, after.windowKind, after.allowance);
   if (was === is)
     return null;
   if (after.pace === "full") {
+    if (keepFreePercent === 0)
+      return null;
     return before !== null && before.windowKind !== null ? paceS3Of(before.windowKind, after.number) : null;
   }
   if (after.windowKind === null || after.until === null)
@@ -24009,7 +24985,7 @@ async function paceAtTurnEnd(input, reply, deps = {}) {
     };
     write(dir, key, after, read !== null ? basis : null);
     const working = liveCount(readLiveness(field2(input, "session_id"), field2(input, "cwd") ?? process.cwd(), deps.liveness));
-    const text = paceChangeText(before, after, working, now);
+    const text = paceChangeText(before, after, working, now, basis.keepFreePercent);
     if (text !== null)
       reply.notice(text);
   } catch {
@@ -24138,9 +25114,9 @@ function paceHoldText(input, toolInput, deps = {}) {
 }
 
 // dist/risky/facts.js
-import { existsSync as existsSync6, lstatSync, readdirSync as readdirSync8, readFileSync as readFileSync17, realpathSync as realpathSync5, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync7, lstatSync as lstatSync2, readdirSync as readdirSync8, readFileSync as readFileSync19, realpathSync as realpathSync6, statSync as statSync7 } from "node:fs";
 import { homedir as homedir7, tmpdir as tmpdir2 } from "node:os";
-import { basename as pathBasename, dirname as dirname5, isAbsolute, join as join11, relative as relative4, resolve as resolve3, sep as sep2 } from "node:path";
+import { basename as pathBasename, dirname as dirname6, isAbsolute as isAbsolute2, join as join12, relative as relative5, resolve as resolve4, sep as sep3 } from "node:path";
 
 // dist/risky/shell.js
 var MAX_DEPTH = 8;
@@ -24515,7 +25491,7 @@ var Splitter = class _Splitter {
     const script = innerScript(words);
     if (script !== void 0) {
       if (this.depth < MAX_DEPTH) {
-        this.child(script, basename(words[0].text) === "eval").parseList(0, null);
+        this.child(script, basename2(words[0].text) === "eval").parseList(0, null);
       }
       return;
     }
@@ -24584,7 +25560,7 @@ function unwrap(input) {
       words = words.slice(1);
       continue;
     }
-    const prog = basename(name);
+    const prog = basename2(name);
     const valueOptions = WRAPPER_VALUE_OPTIONS[prog];
     if (valueOptions === void 0)
       return words;
@@ -24628,7 +25604,7 @@ function unwrap(input) {
 }
 var SHELLS = /* @__PURE__ */ new Set(["bash", "sh", "zsh", "dash", "ksh"]);
 function innerScript(words) {
-  const prog = basename(words[0].text);
+  const prog = basename2(words[0].text);
   if (prog === EVAL_PROGRAM)
     return words.slice(1).map((w) => w.text).join(" ");
   if (!SHELLS.has(prog))
@@ -24663,13 +25639,13 @@ function innerScript(words) {
 }
 function readsScriptFromInput(raw) {
   const words = unwrap(raw);
-  if (words.length === 0 || !SHELLS.has(basename(words[0].text)))
+  if (words.length === 0 || !SHELLS.has(basename2(words[0].text)))
     return false;
   if (innerScript(words) !== void 0)
     return false;
   return words.slice(1).every((w) => w.text.startsWith("-") || w.text.startsWith("+"));
 }
-function basename(word) {
+function basename2(word) {
   const k = Math.max(word.lastIndexOf("/"), word.lastIndexOf("\\"));
   return k < 0 ? word : word.slice(k + 1);
 }
@@ -24684,7 +25660,7 @@ function namesNeverFollowed(line2, commands) {
   const sourced = commands.some((c) => c.words[0] !== void 0 && (c.words[0].text === "source" || c.words[0].text === "."));
   const evaluated = commands.some((c) => c.inPlace === true);
   const indirect = commands.some((c) => {
-    const prog = c.words[0] === void 0 ? "" : basename(c.words[0].text);
+    const prog = c.words[0] === void 0 ? "" : basename2(c.words[0].text);
     return prog === "trap" || prog === "builtin" || REFERENCE_BINDERS.has(prog) && c.words.slice(1).some((w) => /^-[A-Za-z]*n/.test(w.text));
   });
   const fns = functionsIn(line2);
@@ -24708,7 +25684,7 @@ function namesNeverFollowed(line2, commands) {
           out.add(hit[1]);
       }
     }
-    const prog = c.words[0] === void 0 ? "" : basename(c.words[0].text);
+    const prog = c.words[0] === void 0 ? "" : basename2(c.words[0].text);
     const args2 = c.words.slice(1).map((w) => w.text);
     if (BINDERS.has(prog) || prog === "unset") {
       for (const a of args2) {
@@ -24933,7 +25909,7 @@ var LineVariables = class {
     }
   }
   update(cmd, before) {
-    const prog = cmd.words[0] === void 0 ? "" : basename(cmd.words[0].text);
+    const prog = cmd.words[0] === void 0 ? "" : basename2(cmd.words[0].text);
     let settings = [];
     if (cmd.assigns !== void 0)
       settings = cmd.assigns;
@@ -25127,7 +26103,7 @@ function expandWord(word, vars) {
   return { text: v.text, literal: !pattern };
 }
 function expandCommand(cmd, vars) {
-  const first = cmd.words[0] === void 0 ? "" : basename(cmd.words[0].text);
+  const first = cmd.words[0] === void 0 ? "" : basename2(cmd.words[0].text);
   const keepEmpty = FOLDER_CHANGERS.has(first);
   const words = [];
   cmd.words.forEach((w, i) => {
@@ -25171,7 +26147,7 @@ function pathsMade(cmd) {
   const words = cmd.words;
   if (words.length === 0)
     return [];
-  const prog = basename(words[0].text);
+  const prog = basename2(words[0].text);
   const args2 = words.slice(1);
   if (prog === "mkdir") {
     const out = [];
@@ -25211,7 +26187,7 @@ function pathsMade(cmd) {
     if (ops.length >= 2)
       return [{ word: ops[ops.length - 1], by: "clone" }];
     if (ops.length === 1 && ops[0].literal) {
-      const name = basename(ops[0].text.replace(/\/+$/, "")).replace(/\.git$/, "");
+      const name = basename2(ops[0].text.replace(/\/+$/, "")).replace(/\.git$/, "");
       if (name !== "" && !name.includes(":"))
         return [{ word: { text: name, literal: true }, by: "clone" }];
     }
@@ -25224,24 +26200,6 @@ function pathsMade(cmd) {
   return [];
 }
 
-// dist/risky/types.js
-var RISKY_ACTION_TYPES = [
-  "delete-files",
-  "discard-unsaved",
-  "rewrite-shared-history",
-  "delete-unmerged-work",
-  "wipe-data",
-  "read-credentials",
-  "publish",
-  "deploy",
-  "shrink-record",
-  "outside-own-copy"
-];
-function riskyTypeOrder(type) {
-  return RISKY_ACTION_TYPES.indexOf(type);
-}
-var CHECKED_TOOLS = ["Bash", "Read", "Grep", "Write", "Edit", "MultiEdit", "NotebookEdit", "Agent"];
-
 // dist/risky/recognise.js
 function madeKey(dirs, word) {
   return [...dirs.map((d) => d.text), word.text].join("\0");
@@ -25405,7 +26363,7 @@ function surelyRuns(simple, before) {
 }
 function folderAfter(prev, simple, before) {
   const first = simple.words[0];
-  if (first === void 0 || !FOLDER_CHANGERS.has(basename(first.text)))
+  if (first === void 0 || !FOLDER_CHANGERS.has(basename2(first.text)))
     return prev;
   const dirs = prev?.dirs ?? [];
   const unknown2 = { dirs, known: false };
@@ -25414,7 +26372,7 @@ function folderAfter(prev, simple, before) {
     return prev;
   if (simple.next === "||" || before === "||")
     return unknown2;
-  const prog = basename(first.text);
+  const prog = basename2(first.text);
   if (simple.inPlace === true || simple.conditional === true || prog === "popd")
     return unknown2;
   let args2 = simple.words.slice(1);
@@ -25458,7 +26416,7 @@ function recogniseSimple(cmd) {
 }
 function programForms(words) {
   const forms = [words];
-  const prog = basename(words[0].text);
+  const prog = basename2(words[0].text);
   let rest;
   if (prog === "npx" || prog === "bunx" || prog === "pnpx") {
     rest = skipRunnerOptions(words.slice(1));
@@ -25504,7 +26462,7 @@ var PROGRAM_MATCHERS = /* @__PURE__ */ new Map([
   ["git", (cmd, args2) => gitMatch(cmd, args2)]
 ]);
 function recogniseWords(cmd, words) {
-  const prog = basename(words[0].text);
+  const prog = basename2(words[0].text);
   const args2 = words.slice(1);
   const own = PROGRAM_MATCHERS.get(prog);
   if (own !== void 0)
@@ -25585,7 +26543,7 @@ function findMatch(cmd, args2) {
     if (t === FIND_DELETE_ACTION)
       deletes = true;
     if ((t === "-exec" || t === "-execdir" || t === "-ok" || t === "-okdir") && i + 1 < args2.length) {
-      const inner = basename(args2[i + 1].text);
+      const inner = basename2(args2[i + 1].text);
       const viaGit = inner === "git" && args2[i + 2]?.text === "rm";
       if (FIND_DELETERS.has(inner) || viaGit) {
         deletes = true;
@@ -25633,8 +26591,9 @@ function findFilterOf(expr) {
   return names.length === 0 && excluded.length === 0 ? void 0 : { names, excluded };
 }
 var GIT_GLOBAL_VALUE_OPTIONS = /* @__PURE__ */ new Set(["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--config-env", "--super-prefix", "--exec-path", "--attr-source", "--list-cmds"]);
-function gitMatch(cmd, args2) {
+function gitArgsOf(args2) {
   const dirs = [];
+  const config2 = [];
   let gitDir;
   let workTree;
   let i = 0;
@@ -25660,11 +26619,92 @@ function gitMatch(cmd, args2) {
       gitDir = value;
     if (name === "--work-tree" && value)
       workTree = value;
+    if ((name === "-c" || name === "--config-env") && value)
+      config2.push({ word: value, fromEnv: name === "--config-env" });
   }
-  const git2 = { dirs, ...gitDir ? { gitDir } : {}, ...workTree ? { workTree } : {} };
-  const sub = args2[i]?.text;
+  return { git: { dirs, ...gitDir ? { gitDir } : {}, ...workTree ? { workTree } : {} }, at: i, config: config2 };
+}
+function gitMatch(cmd, args2) {
+  const { git: git2, at, config: config2 } = gitArgsOf(args2);
+  const sub = args2[at]?.text;
   const own = sub === void 0 ? void 0 : GIT_SUBCOMMAND_MATCHERS.get(sub);
-  return own === void 0 ? [] : own(cmd, args2.slice(i + 1), git2);
+  return own === void 0 ? [] : own(cmd, args2.slice(at + 1), git2, config2);
+}
+var PUSH_ALL_REFS_OPTION = "--mirror";
+function hasLongAsGitReads(args2, name) {
+  for (const a of args2) {
+    if (a.text === "--")
+      return false;
+    const spelled = a.text.split("=")[0];
+    if (spelled.length >= 3 && spelled.startsWith("--") && name.startsWith(spelled))
+      return true;
+  }
+  return false;
+}
+function configNameOf(c) {
+  const t = c.word.text;
+  const eq = t.indexOf("=");
+  return eq < 0 ? t : t.slice(0, eq);
+}
+function configValueOf(c) {
+  if (c.fromEnv || !c.word.literal)
+    return null;
+  const t = c.word.text;
+  const eq = t.indexOf("=");
+  return eq < 0 ? true : t.slice(eq + 1);
+}
+function configNameUnknown(name) {
+  return /[$`*?[]/.test(name);
+}
+var GIT_FALSE = /^(false|no|off|[-+]?0+)?$/i;
+function configMirrors(config2) {
+  return config2.some((c) => {
+    const name = configNameOf(c);
+    if (configNameUnknown(name))
+      return true;
+    if (!/^remote\..+\.mirror$/i.test(name))
+      return false;
+    const value = configValueOf(c);
+    return value === true || value === null || !GIT_FALSE.test(value);
+  });
+}
+function pushMirrors(rest, config2) {
+  return hasLongAsGitReads(rest, PUSH_ALL_REFS_OPTION) || configMirrors(config2);
+}
+var SAVED_NAMESPACE = SAVED_REF_PREFIX.split("/").slice(0, 2).join("/") + "/";
+function refspecSendsSaves(text) {
+  if (text.includes(SAVED_NAMESPACE))
+    return true;
+  const src = text.replace(/^\+/, "").split(":")[0];
+  const star = src.indexOf("*");
+  return star >= 0 && SAVED_NAMESPACE.startsWith(src.slice(0, star));
+}
+function configPushSendsSaves(config2) {
+  return config2.some((c) => {
+    const name = configNameOf(c);
+    if (configNameUnknown(name))
+      return true;
+    if (!/^remote\..+\.push$/i.test(name))
+      return false;
+    const value = configValueOf(c);
+    return value === null || value !== true && refspecSendsSaves(value);
+  });
+}
+function pushesSavedRefs(command) {
+  for (const cmd of splitCommand(command)) {
+    if (cmd.words.length === 0 || basename2(cmd.words[0].text) !== "git")
+      continue;
+    const args2 = cmd.words.slice(1);
+    const { at, config: config2 } = gitArgsOf(args2);
+    if (args2[at]?.text !== "push")
+      continue;
+    const rest = args2.slice(at + 1);
+    if (pushMirrors(rest, config2) || configPushSendsSaves(config2))
+      return true;
+    if (rest.some((w) => refspecSendsSaves(w.text)))
+      return true;
+  }
+  return false;
 }
 var GIT_SUBCOMMAND_MATCHERS = /* @__PURE__ */ new Map([
   ["rm", (cmd, rest, git2) => gitRm(cmd, rest, git2)],
@@ -25675,7 +26715,7 @@ var GIT_SUBCOMMAND_MATCHERS = /* @__PURE__ */ new Map([
   ["clean", (cmd, rest, git2) => gitClean(cmd, rest, git2)],
   ["stash", (cmd, rest, git2) => gitStash(cmd, rest, git2)],
   ["worktree", (cmd, rest, git2) => gitWorktree(cmd, rest, git2)],
-  ["push", (cmd, rest, git2) => gitPush(cmd, rest, git2)],
+  ["push", (cmd, rest, git2, config2) => gitPush(cmd, rest, git2, config2)],
   ["branch", (cmd, rest, git2) => gitBranch(cmd, rest, git2)]
 ]);
 function gitSwitch(cmd, rest, git2) {
@@ -25700,7 +26740,8 @@ function gitRm(cmd, rest, git2) {
   const targets = operands(rest, /* @__PURE__ */ new Set(["--pathspec-from-file"]));
   if (targets.length === 0)
     return [];
-  return [{ type: "delete-files", form: "plain", program: "git rm", targets, git: git2, command: cmd }];
+  const form = gitRmRecursive(cmd.words) ? "recursive" : "plain";
+  return [{ type: "delete-files", form, program: "git rm", targets, git: git2, command: cmd }];
 }
 function gitReset(cmd, rest, git2) {
   const hard = hasLong(rest, "--hard");
@@ -25753,7 +26794,7 @@ function gitWorktree(cmd, rest, git2) {
   return [{ type: "discard-unsaved", form: "worktree-remove", paths: operands(args2), git: git2, command: cmd }];
 }
 var PUSH_VALUE_OPTIONS = /* @__PURE__ */ new Set(["-o", "--push-option", "--repo", "--receive-pack", "--exec"]);
-function gitPush(cmd, rest, git2) {
+function gitPush(cmd, rest, git2, config2) {
   if (hasShort(rest, "n") || hasLong(rest, "--dry-run"))
     return [];
   const ops = operands(rest, PUSH_VALUE_OPTIONS);
@@ -25762,7 +26803,7 @@ function gitPush(cmd, rest, git2) {
   const force = hasShort(rest, "f") || hasLong(rest, "--force");
   const forceWithLease = hasLong(rest, "--force-with-lease");
   const forceIfIncludes = hasLong(rest, "--force-if-includes");
-  const mirror = hasLong(rest, "--mirror");
+  const mirror = pushMirrors(rest, config2);
   const deletes = hasShort(rest, "d") || hasLong(rest, "--delete") || refspecs.some((r) => r.text.startsWith(":") && r.text.length > 1);
   const plusRefspec = refspecs.some((r) => r.text.startsWith("+"));
   if (!(force || forceWithLease || forceIfIncludes || mirror || deletes || plusRefspec))
@@ -25802,7 +26843,7 @@ function wipeDataMatch(cmd, prog, args2, words) {
     const execAt = args2.findIndex((a) => a.text === "exec" || a.text === "run");
     if (execAt >= 0) {
       for (let i = execAt + 1; i < args2.length; i++) {
-        const inner = basename(args2[i].text);
+        const inner = basename2(args2[i].text);
         if (SQL_CLIENTS.has(inner) || inner === "dropdb" || inner === "redis-cli") {
           return wipeDataMatch(cmd, inner, args2.slice(i + 1), args2.slice(i));
         }
@@ -26135,7 +27176,7 @@ function shellRecordMatches(cmd, found2) {
   for (const m of found2) {
     if (m.type !== "delete-files" || m.program === "find" || m.program === "git clean" || m.command !== cmd)
       continue;
-    const recursive = m.form === "recursive" || m.program === "git rm" && gitRmRecursive(cmd.words);
+    const recursive = m.form === "recursive";
     const targets = recursive ? m.targets : m.targets.filter((w) => mayBeRecordWord(w));
     if (targets.length === 0)
       continue;
@@ -26149,7 +27190,7 @@ function shellRecordMatches(cmd, found2) {
     });
   }
   const words = cmd.words;
-  const prog = words.length > 0 ? basename(words[0].text) : "";
+  const prog = words.length > 0 ? basename2(words[0].text) : "";
   const args2 = words.slice(1);
   if (prog === TRUNCATE_PROGRAM) {
     const targets = operands(args2, /* @__PURE__ */ new Set(["-s", "--size", "-r", "--reference"])).filter((w) => mayBeRecordWord(w));
@@ -26182,7 +27223,7 @@ function movesStdout(r) {
   return [">", ">>", ">|", ">&"].includes(r.op) && (r.fd === void 0 || r.fd === "1");
 }
 function savedObjectShown(words) {
-  if (words.length !== 3 || basename(words[0].text) !== "git" || words[1].text !== "show" || !words[2].literal)
+  if (words.length !== 3 || basename2(words[0].text) !== "git" || words[1].text !== "show" || !words[2].literal)
     return void 0;
   return /^[0-9a-f]{7,64}:[^:]+$/.test(words[2].text) ? words[2].text : void 0;
 }
@@ -26285,13 +27326,13 @@ var Env = class {
   description;
   projectCommonDir;
   constructor(ctx) {
-    this.projectDir = realOrSelf(resolve3(ctx.projectDir));
-    this.cwd = realOrSelf(resolve3(this.projectDir, ctx.cwd));
-    this.home = realOrSelf(resolve3(ctx.home ?? homedir7()));
+    this.projectDir = realOrSelf(resolve4(ctx.projectDir));
+    this.cwd = realOrSelf(resolve4(this.projectDir, ctx.cwd));
+    this.home = realOrSelf(resolve4(ctx.home ?? homedir7()));
     this.timeoutMs = ctx.gitTimeoutMs ?? FACTS_GIT_TIMEOUT_MS;
-    this.tempDir = realOrSelf(resolve3(ctx.tempDir ?? tmpdir2()));
+    this.tempDir = realOrSelf(resolve4(ctx.tempDir ?? tmpdir2()));
     const roots = ctx.tempRoots ?? [this.tempDir, tmpdir2(), ...TEMP_ROOTS];
-    this.tempRoots = [...new Set(roots.map((r) => realOrSelf(resolve3(r))))].filter((r) => !isInside(this.projectDir, r));
+    this.tempRoots = [...new Set(roots.map((r) => realOrSelf(resolve4(r))))].filter((r) => !isInside(this.projectDir, r));
   }
   isTemp(abs) {
     return this.tempRoots.some((r) => isInside(abs, r));
@@ -26301,7 +27342,7 @@ var Env = class {
   }
   display(abs) {
     if (isInside(abs, this.projectDir)) {
-      const rel = relative4(this.projectDir, abs);
+      const rel = relative5(this.projectDir, abs);
       return rel === "" ? "." : toSlash(rel);
     }
     return toSlash(abs);
@@ -26311,7 +27352,7 @@ var Env = class {
       return this.description;
     this.description = null;
     try {
-      const raw = JSON.parse(readFileSync17(join11(repoRoot, SYSTEM_DESCRIPTION_REL), "utf-8"));
+      const raw = JSON.parse(readFileSync19(join12(repoRoot, SYSTEM_DESCRIPTION_REL), "utf-8"));
       const checked = checkSystemDescription(raw);
       if (checked.ok)
         this.description = checked.description;
@@ -26342,7 +27383,7 @@ var Env = class {
       return false;
     let dir = abs;
     while (!isDirectory(dir)) {
-      const up = dirname5(dir);
+      const up = dirname6(dir);
       if (up === dir)
         return false;
       dir = up;
@@ -26354,40 +27395,40 @@ var Env = class {
     if (!r.ok)
       return null;
     const d = r.value.trim();
-    return d === "" ? null : realOrSelf(resolve3(dir, d));
+    return d === "" ? null : realOrSelf(resolve4(dir, d));
   }
 };
 function realOrSelf(p) {
   try {
-    return realpathSync5(p);
+    return realpathSync6(p);
   } catch {
     return p;
   }
 }
 function toSlash(p) {
-  return sep2 === "/" ? p : p.split(sep2).join("/");
+  return sep3 === "/" ? p : p.split(sep3).join("/");
 }
 function isInside(child, parent) {
-  const rel = relative4(parent, child);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+  const rel = relative5(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
 }
 function resolveHome(text, home, base) {
   if (text === "~")
     return home;
   if (text.startsWith("~/"))
-    return join11(home, text.slice(2));
-  return resolve3(base, text);
+    return join12(home, text.slice(2));
+  return resolve4(base, text);
 }
 function realTarget(abs) {
-  const parent = dirname5(abs);
+  const parent = dirname6(abs);
   if (parent === abs)
     return abs;
-  return join11(realOrSelf(parent), pathBasename(abs));
+  return join12(realOrSelf(parent), pathBasename(abs));
 }
 function wordPath(word, base, env) {
   if (word.temp !== void 0) {
-    const root = word.temp.base === "mktemp" ? join11(env.tempDir, ".halfcycle-mktemp-new") : env.tempDir;
-    return resolve3(`${root}${word.temp.suffix}`);
+    const root = word.temp.base === "mktemp" ? join12(env.tempDir, ".halfcycle-mktemp-new") : env.tempDir;
+    return resolve4(`${root}${word.temp.suffix}`);
   }
   return word.literal ? resolveHome(word.text, env.home, base) : null;
 }
@@ -26396,7 +27437,7 @@ function follow(start, prefix, dirs, m, env) {
   let fresh = start.fresh;
   let freshRoot = start.freshRoot;
   const seen = [...prefix];
-  const insideFresh = (p) => freshRoot !== void 0 && isInside(resolve3(p), resolve3(freshRoot));
+  const insideFresh = (p) => freshRoot !== void 0 && isInside(resolve4(p), resolve4(freshRoot));
   const mark = (by) => {
     if (fresh !== void 0 && insideFresh(cwd))
       return;
@@ -26525,14 +27566,14 @@ function expandBraces(text) {
   return body.split(",").map((b) => `${head}${b}${tail}`);
 }
 function globPath(abs) {
-  const root = abs.startsWith(sep2) ? sep2 : "";
-  const segments = abs.split(sep2).filter((s) => s !== "");
+  const root = abs.startsWith(sep3) ? sep3 : "";
+  const segments = abs.split(sep3).filter((s) => s !== "");
   let current = [root === "" ? "." : root];
   for (const segment of segments) {
     const next = [];
     if (!/[*?[]/.test(segment)) {
       for (const c of current)
-        next.push(join11(c, segment));
+        next.push(join12(c, segment));
     } else {
       const re = segmentPattern(segment);
       for (const c of current) {
@@ -26546,7 +27587,7 @@ function globPath(abs) {
           if (n.startsWith(".") && !segment.startsWith("."))
             continue;
           if (re.test(n))
-            next.push(join11(c, n));
+            next.push(join12(c, n));
         }
       }
     }
@@ -26582,7 +27623,7 @@ function segmentPattern(segment) {
 }
 function pathExists(p) {
   try {
-    lstatSync(p);
+    lstatSync2(p);
     return true;
   } catch {
     return false;
@@ -26590,28 +27631,28 @@ function pathExists(p) {
 }
 function isEmptyFolder(p) {
   try {
-    return lstatSync(p).isDirectory() && readdirSync8(p).length === 0;
+    return lstatSync2(p).isDirectory() && readdirSync8(p).length === 0;
   } catch {
     return false;
   }
 }
 function isFolder(p) {
   try {
-    return statSync6(p).isDirectory();
+    return statSync7(p).isDirectory();
   } catch {
     return false;
   }
 }
 function isDirectory(p) {
   try {
-    return lstatSync(p).isDirectory();
+    return lstatSync2(p).isDirectory();
   } catch {
     return false;
   }
 }
-function filesUnder(targets, repoRoot, env, keep) {
+function filesUnder(targets, repoRoot, env, keep, seen) {
   const specs = targets.map((t) => {
-    const rel = toSlash(relative4(repoRoot, t));
+    const rel = toSlash(relative5(repoRoot, t));
     return rel === "" ? "." : rel;
   });
   const tracked = env.git(["--literal-pathspecs", "ls-files", "--full-name", "-z", "--", ...specs], repoRoot);
@@ -26645,6 +27686,8 @@ function filesUnder(targets, repoRoot, env, keep) {
         goneFromDisk.add(e.path);
     }
   }
+  if (seen !== void 0)
+    seen.ignored = ignored.length;
   const out = /* @__PURE__ */ new Map();
   for (const path of tracked.value.split("\0")) {
     if (path === "" || goneFromDisk.has(path))
@@ -26672,12 +27715,12 @@ function findKeeps(filter, roots, repoRoot) {
   const names = filter.names.map((n) => findPattern(n.pattern, n.fold, false));
   const excluded = filter.excluded.map((p) => findPattern(p, false, true));
   const steps = (rel) => {
-    const abs = join11(repoRoot, rel);
+    const abs = join12(repoRoot, rel);
     const out = [];
     for (const r of roots) {
       if (!isInside(abs, r.abs))
         continue;
-      const below = toSlash(relative4(r.abs, abs)).split("/").filter((x) => x !== "");
+      const below = toSlash(relative5(r.abs, abs)).split("/").filter((x) => x !== "");
       const rootName = r.text === null ? pathBasename(r.abs) : r.text.replace(/\/+$/, "").split("/").pop() || r.text;
       const prefixes = r.text === null ? [] : [.../* @__PURE__ */ new Set([r.text, r.text.replace(/\/+$/, "") || r.text])];
       const chain = [{ name: rootName, printed: r.text === null ? [] : [r.text] }];
@@ -26726,27 +27769,27 @@ function findPattern(pattern, fold, whole) {
   return new RegExp(`${re}$`, fold ? "i" : "");
 }
 function walkRoots(ignoredFolders, specs) {
-  const under = (child, parent) => parent === "." || child === parent || child.startsWith(`${parent}/`);
+  const under2 = (child, parent) => parent === "." || child === parent || child.startsWith(`${parent}/`);
   const roots = /* @__PURE__ */ new Set();
   for (const raw of ignoredFolders) {
     const folder = raw.replace(/\/+$/, "");
     for (const spec of specs) {
-      if (under(folder, spec))
+      if (under2(folder, spec))
         roots.add(folder);
-      else if (under(spec, folder))
+      else if (under2(spec, folder))
         roots.add(spec);
     }
   }
   const all = [...roots];
-  return all.filter((r) => !all.some((o) => o !== r && under(r, o)));
+  return all.filter((r) => !all.some((o) => o !== r && under2(r, o)));
 }
 function credentialFilesIn(folders, repoRoot, deadline, skip) {
   const out = [];
   const stack = [];
   for (const f of folders) {
-    if (isDirectory(join11(repoRoot, f)))
+    if (isDirectory(join12(repoRoot, f)))
       stack.push(f);
-    else if (pathExists(join11(repoRoot, f)) && isCredentialPath(f))
+    else if (pathExists(join12(repoRoot, f)) && isCredentialPath(f))
       out.push(f);
   }
   let seen = 0;
@@ -26754,7 +27797,7 @@ function credentialFilesIn(folders, repoRoot, deadline, skip) {
     const rel = stack.pop();
     let entries;
     try {
-      entries = readdirSync8(join11(repoRoot, rel), { withFileTypes: true });
+      entries = readdirSync8(join12(repoRoot, rel), { withFileTypes: true });
     } catch {
       continue;
     }
@@ -26851,7 +27894,7 @@ function deleteFilesFacts(m, env) {
     for (const raw of expanded) {
       const abs = realTarget(raw);
       written.set(abs, word.literal ? word.text : null);
-      if (abs === sep2 || abs === env.home || abs !== env.projectDir && isInside(env.projectDir, abs)) {
+      if (abs === sep3 || abs === env.home || abs !== env.projectDir && isInside(env.projectDir, abs)) {
         guarded.push(abs);
       } else if (isInside(abs, env.projectDir) || !env.isTemp(abs) && env.sameRepository(abs)) {
         if (pathExists(abs))
@@ -26863,20 +27906,22 @@ function deleteFilesFacts(m, env) {
     return cannot({ kind: "paths", paths: guarded.map((g) => toSlash(g)) });
   if (unseen)
     return cannot(null);
-  const plainFolderRefused = m.form === "plain" && !(m.program === "git rm" && gitRmRecursive(m.command?.words ?? []));
+  const plainFolderRefused = m.form === "plain";
   const targets = plainFolderRefused ? inside.filter((t) => !isDirectory(t)) : inside;
   if (targets.length === 0)
     return silentDelete(m);
-  const repoRoot = env.repoRoot(dirname5(targets[0])) ?? env.repoRoot(env.projectDir);
+  const repoRoot = env.repoRoot(dirname6(targets[0])) ?? env.repoRoot(env.projectDir);
   if (repoRoot === null || !targets.every((t) => isInside(t, repoRoot)))
     return cannot(thingFor([], targets, null, env));
   const keep = m.findFilter === void 0 ? void 0 : findKeeps(m.findFilter, targets.map((t) => ({ abs: t, text: written.get(t) ?? null })), repoRoot);
-  const files = filesUnder(targets, repoRoot, env, keep);
+  const seen = { ignored: 0 };
+  const files = filesUnder(targets, repoRoot, env, keep, seen);
   if (files === null)
     return cannot(thingFor([], targets, repoRoot, env));
   const n = files.length;
   const k = files.filter((f) => f.neverSaved).length;
-  const atStake = m.form === "plain" ? k > 0 : n > 0;
+  const closeFold = m.form !== "find" && seen.ignored === 0 && closeFoldsAll(targets, env);
+  const atStake = m.form === "plain" || closeFold ? k > 0 : n > 0;
   if (!atStake)
     return silentDelete(m);
   const thing = thingFor(files.map((f) => f.path), targets, repoRoot, env);
@@ -26889,9 +27934,38 @@ function deleteFilesFacts(m, env) {
     ...m.form === "find" ? { cannotTell: "which-files" } : {},
     thing,
     files: m.form === "find" ? null : n,
-    neverSaved: m.form === "find" ? null : k
+    neverSaved: m.form === "find" ? null : k,
+    ...base.pre.length === 0 ? {
+      save: {
+        repoRoot,
+        paths: targets.map((t) => toSlash(relative5(repoRoot, t)) || "."),
+        ...keep === void 0 ? {} : { keep: (rel) => keep.deletes(rel) },
+        lines: []
+      }
+    } : {}
   };
 }
+function closeFoldsAll(targets, env) {
+  return targets.every((t) => {
+    const root = recordRoot(t, env);
+    if (root === null || !isInside(t, root))
+      return false;
+    const rel = toSlash(relative5(root, t));
+    if (rel === "" || recordPatternFor(rel)?.deleteAsked !== false)
+      return false;
+    let at = root;
+    for (const seg of rel.split("/")) {
+      at = join12(at, seg);
+      try {
+        if (lstatSync2(at).isSymbolicLink())
+          return false;
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  });
+}
 function silentDelete(m) {
   return { type: m.type, match: m, atStake: false, lostForGood: [], recoverable: [], thing: null, files: 0, neverSaved: 0 };
 }
@@ -26949,6 +28023,7 @@ function discardUnsavedFacts(m, env) {
   const repoRoot = env.repoRoot(where.cwd);
   const part = repoRoot === null ? null : owningPart(lost, repoRoot, env);
   const thing = part !== null ? { kind: "part", name: part } : { kind: "paths", paths: lost };
+  const saveable = repoRoot !== null && where.pre.length === 0 && m.form !== "stash-drop" && m.form !== "stash-clear" && m.form !== "worktree-remove";
   return {
     type: m.type,
     match: m,
@@ -26956,7 +28031,8 @@ function discardUnsavedFacts(m, env) {
     lostForGood: [{ kind: "unsaved-changes", count: lost.length }],
     recoverable: [],
     thing,
-    files: lost.length
+    files: lost.length,
+    ...saveable ? { save: { repoRoot, paths: lost, lines: [] } } : {}
   };
 }
 function changedFiles(where, paths, which, env, skipUnmerged = false) {
@@ -27009,8 +28085,9 @@ function restoreTouchesIndex(m) {
 }
 function cleanFacts(m, env) {
   const where = gitFolder(m, env);
-  const lost = where === null ? null : cleanFiles(m, where, env);
-  if (where === null || lost === null) {
+  const cleaned = where === null ? null : cleanFiles(m, where, env);
+  const lost = cleaned === null ? null : cleaned.lost;
+  if (where === null || cleaned === null || lost === null) {
     return { type: m.type, match: m, atStake: true, lostForGood: [], recoverable: [], cannotTell: "which-files", thing: null, files: null, neverSaved: null };
   }
   if (lost.length === 0)
@@ -27025,7 +28102,8 @@ function cleanFacts(m, env) {
     recoverable: [],
     thing: part !== null ? { kind: "part", name: part } : { kind: "paths", paths: lost },
     files: lost.length,
-    neverSaved: lost.length
+    neverSaved: lost.length,
+    ...repoRoot !== null && where.pre.length === 0 ? { save: { repoRoot, paths: cleaned.removed, lines: [] } } : {}
   };
 }
 function cleanFiles(m, where, env) {
@@ -27062,12 +28140,15 @@ function cleanFiles(m, where, env) {
     return null;
   const named = dry.value.split("\n").map((l) => /^Would remove (.*)$/.exec(l)?.[1]).filter((x) => x !== void 0 && x !== "");
   if (named.length === 0)
-    return [];
+    return { lost: [], removed: [] };
   const repoRoot = env.repoRoot(where.cwd);
   if (repoRoot === null)
     return null;
-  const files = filesUnder(named.map((n) => resolve3(where.cwd, n)), repoRoot, env);
-  return files === null ? null : files.filter((f) => f.neverSaved).map((f) => f.path);
+  const abs = named.map((n) => resolve4(where.cwd, n));
+  const files = filesUnder(abs, repoRoot, env);
+  if (files === null)
+    return null;
+  return { lost: files.filter((f) => f.neverSaved).map((f) => f.path), removed: abs.map((a) => toSlash(relative5(repoRoot, a)) || ".") };
 }
 function stashFiles(m, where, env) {
   let refs;
@@ -27107,7 +28188,7 @@ function worktreeFiles(m, where, env) {
   if (path === null)
     return null;
   const abs = realOrSelf(path);
-  if (!existsSync6(abs))
+  if (!existsSync7(abs))
     return [];
   const top = env.repoRoot(abs);
   if (top === null)
@@ -27119,19 +28200,23 @@ function worktreeFiles(m, where, env) {
 }
 function unmergedFacts(m, env) {
   const where = gitFolder(m, env, ["clone"]);
-  const lines2 = [];
+  const leaves = [];
   if (where === null) {
-    lines2.push({ branch: null, commits: null });
+    leaves.push({ line: { branch: null, commits: null }, tip: null });
   } else if (where.fresh === "clone") {
-    lines2.push({ branch: null, commits: 0 });
+    leaves.push({ line: { branch: null, commits: 0 }, tip: null });
   } else if (m.form === "reset-to") {
-    lines2.push(resetLeaves(m.rev, where, env));
+    leaves.push(resetLeaves(m.rev, where, env));
   } else {
     for (const b of m.branches)
-      lines2.push(branchLeaves(b, m.remoteTracking, where, env));
+      leaves.push(branchLeaves(b, m.remoteTracking, where, env));
   }
+  const lines2 = leaves.map((l) => l.line);
   const unknown2 = lines2.some((l) => l.commits === null);
   const total = lines2.reduce((s, l) => s + (l.commits ?? 0), 0);
+  const kept = leaves.filter((l) => (l.line.commits ?? 0) > 0);
+  const repoRoot = where === null || where.fresh !== void 0 || where.pre.length > 0 ? null : env.repoRoot(where.cwd);
+  const saveable = !unknown2 && repoRoot !== null && kept.every((l) => l.tip !== null);
   return {
     type: m.type,
     match: m,
@@ -27139,44 +28224,46 @@ function unmergedFacts(m, env) {
     lostForGood: [],
     recoverable: total > 0 ? [{ kind: "local-changes", count: total }] : [],
     ...unknown2 ? { cannotTell: "which-line" } : {},
-    lines: lines2
+    lines: lines2,
+    ...saveable ? { save: { repoRoot, paths: [], lines: kept.map((l) => ({ name: m.remoteTracking ? null : l.line.branch, commit: l.tip })) } } : {}
   };
 }
 function resetLeaves(rev, where, env) {
   const current = currentBranch(where, env);
+  const at = (commits, tip = null) => ({ line: { branch: current, commits }, tip });
   if (rev === void 0)
-    return { branch: current, commits: 0 };
+    return at(0);
   let target;
   if (rev.gitRev !== void 0) {
     const r2 = env.git([...where.pre, ...rev.gitRev], where.cwd);
     const id = r2.ok ? r2.value.trim() : "";
     if (!/^[0-9a-f]{40,64}$/.test(id))
-      return { branch: current, commits: null };
+      return at(null);
     target = id;
   } else {
     if (!rev.literal || rev.text.startsWith("-"))
-      return { branch: current, commits: null };
+      return at(null);
     target = resolveCommit(rev.text, where, env);
   }
   if (target === null)
-    return { branch: current, commits: 0 };
+    return at(0);
   const head = resolveCommit("HEAD", where, env);
   if (head === null)
-    return { branch: current, commits: 0 };
+    return at(0);
   const excludeCurrent = current === null ? [] : [`--exclude=${current}`];
   const r = env.git([...where.pre, "rev-list", head, "--not", target, ...excludeCurrent, "--branches", "--remotes", "--tags"], where.cwd);
-  return { branch: current, commits: r.ok ? lines(r.value).length : null };
+  return at(r.ok ? lines(r.value).length : null, head);
 }
 function branchLeaves(b, remoteTracking, where, env) {
   if (!b.literal || b.text.startsWith("-"))
-    return { branch: b.literal ? b.text : null, commits: null };
+    return { line: { branch: b.literal ? b.text : null, commits: null }, tip: null };
   const ref = remoteTracking ? `refs/remotes/${b.text}` : `refs/heads/${b.text}`;
   const tip = resolveCommit(ref, where, env);
   if (tip === null)
-    return { branch: b.text, commits: 0 };
+    return { line: { branch: b.text, commits: 0 }, tip: null };
   const exclude = remoteTracking ? ["--branches", `--exclude=${b.text}`, "--remotes", "--tags"] : [`--exclude=${b.text}`, "--branches", "--remotes", "--tags"];
   const r = env.git([...where.pre, "rev-list", tip, "--not", ...exclude], where.cwd);
-  return { branch: b.text, commits: r.ok ? lines(r.value).length : null };
+  return { line: { branch: b.text, commits: r.ok ? lines(r.value).length : null }, tip };
 }
 function currentBranch(where, env) {
   const r = env.git([...where.pre, "symbolic-ref", "--quiet", "--short", "HEAD"], where.cwd);
@@ -27451,7 +28538,7 @@ function publishFacts(m, env) {
   const start = startFolder(m, env);
   if (start !== null && PACKAGE_JSON_PROGRAMS.has(m.program)) {
     try {
-      const pkg = JSON.parse(readFileSync17(join11(start, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync19(join12(start, "package.json"), "utf-8"));
       if (typeof pkg["name"] === "string" && typeof pkg["version"] === "string" && pkg["name"] !== "" && pkg["version"] !== "") {
         name = pkg["name"];
         version2 = pkg["version"];
@@ -27499,9 +28586,9 @@ function shrinkRecordFacts(m, env) {
   for (const file2 of [...found2.values()].sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0)) {
     let before;
     try {
-      if (!lstatSync(file2.abs).isFile())
+      if (!lstatSync2(file2.abs).isFile())
         continue;
-      before = readFileSync17(file2.abs, "utf-8");
+      before = readFileSync19(file2.abs, "utf-8");
     } catch {
       continue;
     }
@@ -27534,7 +28621,8 @@ function shrinkRecordFacts(m, env) {
       lines: lines2,
       removed,
       history: h === null ? null : h.history,
-      unsaved
+      unsaved,
+      ...base.pre.length === 0 ? { save: { repoRoot: file2.root, paths: [file2.rel], lines: [] } } : {}
     };
   });
 }
@@ -27552,7 +28640,7 @@ function recordRoot(abs, env) {
     return null;
   let dir = abs;
   while (!isDirectory(dir)) {
-    const up = dirname5(dir);
+    const up = dirname6(dir);
     if (up === dir)
       return null;
     dir = up;
@@ -27563,7 +28651,7 @@ function recordFileAt(abs, env) {
   const root = recordRoot(abs, env);
   if (root === null || !isInside(abs, root))
     return null;
-  const rel = toSlash(relative4(root, abs));
+  const rel = toSlash(relative5(root, abs));
   if (rel === "")
     return null;
   const row = recordPatternFor(rel);
@@ -27573,11 +28661,11 @@ function recordFilesUnder(folder, env) {
   const root = recordRoot(folder, env);
   if (root === null)
     return [];
-  const relFolder = toSlash(relative4(root, folder));
+  const relFolder = toSlash(relative5(root, folder));
   const starts = /* @__PURE__ */ new Set();
   for (const { pattern } of PROJECT_RECORD_PATTERNS) {
     if (relFolder === "" || patternOwns(relFolder, pattern))
-      starts.add(join11(root, pattern));
+      starts.add(join12(root, pattern));
     else if (patternOwns(pattern, relFolder))
       starts.add(folder);
   }
@@ -27591,7 +28679,7 @@ function recordFilesUnder(folder, env) {
     seen.add(p);
     let st;
     try {
-      st = lstatSync(p);
+      st = lstatSync2(p);
     } catch {
       continue;
     }
@@ -27603,7 +28691,7 @@ function recordFilesUnder(folder, env) {
         continue;
       }
       for (const n of names)
-        stack.push(join11(p, n));
+        stack.push(join12(p, n));
     } else if (st.isFile()) {
       const r = recordFileAt(p, env);
       if (r !== null)
@@ -27616,7 +28704,7 @@ function recordHistory(files, env) {
   const out = /* @__PURE__ */ new Map();
   const byTree = /* @__PURE__ */ new Map();
   for (const abs of files) {
-    const top = env.repoRoot(dirname5(abs));
+    const top = env.repoRoot(dirname6(abs));
     if (top === null || !isInside(abs, top))
       continue;
     const list = byTree.get(top) ?? [];
@@ -27624,7 +28712,7 @@ function recordHistory(files, env) {
     byTree.set(top, list);
   }
   for (const [top, list] of byTree) {
-    const specs = list.map((abs) => toSlash(relative4(top, abs)));
+    const specs = list.map((abs) => toSlash(relative5(top, abs)));
     const tracked = trackedOf(specs, top, env);
     if (tracked === null)
       continue;
@@ -27705,14 +28793,7 @@ function oneLine(text) {
   return text.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").replace(/\s+/g, " ").trim();
 }
 function questionFor(facts, description) {
-  const said = /* @__PURE__ */ new Set();
-  const staked = facts.filter((f) => f.atStake).map((f, i) => ({ f, i })).sort((a, b) => riskyTypeOrder(a.f.type) - riskyTypeOrder(b.f.type) || a.i - b.i).map(({ f }) => f).filter((f) => {
-    const part = `${whatOf(f)} ${lostOf(f)}`;
-    if (said.has(part))
-      return false;
-    said.add(part);
-    return true;
-  });
+  const staked = orderedStaked(facts);
   const reason = reasonSentence(description);
   if (staked.length === 0)
     return couldNotTellQuestion(description);
@@ -27721,15 +28802,45 @@ function questionFor(facts, description) {
     return `Halfcycle: ${whatOf(only)} ${reason} If you allow it, ${lostOf(only)} ${NOTHING_LOST_ON_NO}`;
   }
   const shown2 = staked.slice(0, MAX_LISTED).map((f) => `${whatOf(f)} If you allow it, ${lostOf(f)}`);
-  const more = staked.length - shown2.length;
-  const moreLine = more > 0 ? ` And ${more} more risky ${more === 1 ? "step" : "steps"}.` : "";
-  return `Halfcycle: ${shown2.join(" ")}${moreLine} ${reason} ${NOTHING_LOST_ON_NO}`;
+  return `Halfcycle: ${shown2.join(" ")}${moreLine(staked.length - shown2.length)} ${reason} ${NOTHING_LOST_ON_NO}`;
+}
+function orderedStaked(facts) {
+  const said = /* @__PURE__ */ new Set();
+  return facts.filter((f) => f.atStake).map((f, i) => ({ f, i })).sort((a, b) => riskyTypeOrder(a.f.type) - riskyTypeOrder(b.f.type) || a.i - b.i).map(({ f }) => f).filter((f) => {
+    const part = `${whatOf(f)} ${lostOf(f)}`;
+    if (said.has(part))
+      return false;
+    said.add(part);
+    return true;
+  });
+}
+function moreLine(more) {
+  return more > 0 ? ` And ${more} more risky ${more === 1 ? "step" : "steps"}.` : "";
+}
+var UNNAMED_PUSH_WHAT = "Replace a line of work on the shared copy.";
+function whatsText(facts, extraPush = false) {
+  const staked = orderedStaked(facts);
+  const items = staked.map((f) => ({ order: riskyTypeOrder(f.type), what: whatOf(f) }));
+  const pushOrder = riskyTypeOrder("rewrite-shared-history");
+  if (extraPush && !staked.some((f) => f.type === "rewrite-shared-history")) {
+    const at = items.findIndex((x) => x.order > pushOrder);
+    items.splice(at < 0 ? items.length : at, 0, { order: pushOrder, what: UNNAMED_PUSH_WHAT });
+  }
+  const shown2 = items.slice(0, MAX_LISTED).map((x) => x.what);
+  return `${shown2.join(" ")}${moreLine(items.length - shown2.length)}`;
+}
+function typeSentenceFor(facts, extraPush = false) {
+  const whats = whatsText(facts, extraPush);
+  return whats === "" ? AUTONOMY_COULD_NOT_TELL_SENTENCE : `Halfcycle: ${whats}`;
+}
+function savedWhatFor(facts) {
+  return whatsText(facts);
 }
 function refusalText(question) {
   return `${question} ${TURN_QUESTIONS_ON_LINE}`;
 }
 function couldNotTellQuestion(description) {
-  return `Halfcycle: This step can delete, overwrite, publish or show something that cannot be taken back, and Halfcycle could not work out what. ${reasonSentence(description)} If you allow it, whatever it changes may not be possible to bring back. ${NOTHING_LOST_ON_NO}`;
+  return `${AUTONOMY_COULD_NOT_TELL_SENTENCE} ${reasonSentence(description)} If you allow it, whatever it changes may not be possible to bring back. ${NOTHING_LOST_ON_NO}`;
 }
 function whatOf(f) {
   switch (f.type) {
@@ -27811,7 +28922,7 @@ function pushWhat(f) {
   const verb = lines2.length > 0 && lines2.every((l) => l.deletes) ? "Delete" : "Replace";
   const named = lines2.filter((l) => l.branch !== null).map((l) => l.branch);
   if (named.length === 0)
-    return `${verb} a line of work on the shared copy.`;
+    return verb === "Replace" ? UNNAMED_PUSH_WHAT : `${verb} a line of work on the shared copy.`;
   return `${verb} the shared copy's ${named.length === 1 ? "line" : "lines"} of work ${listNames(named)}.`;
 }
 function pushLost(f) {
@@ -28013,16 +29124,71 @@ function answerModeFor(permissionMode) {
   return typeof permissionMode === "string" && QUESTIONS_ON_MODES.has(permissionMode) ? "questions-on" : "questions-off";
 }
 var REFUSED_IN_EVERY_MODE = /* @__PURE__ */ new Set(["outside-own-copy"]);
-function decide(action, facts, mode) {
+function autonomousRowOf(type) {
+  switch (type) {
+    case "delete-files":
+    case "discard-unsaved":
+    case "delete-unmerged-work":
+    case "shrink-record":
+      return "save";
+    case "rewrite-shared-history":
+    case "wipe-data":
+      return "wait-item-1";
+    case "publish":
+    case "deploy":
+      return "publish";
+    case "read-credentials":
+      return "never";
+    case "outside-own-copy":
+      return "every-mode";
+    default: {
+      const unhandled = type;
+      return unhandled;
+    }
+  }
+}
+function savedByAutonomy(type) {
+  return autonomousRowOf(type) === "save";
+}
+function ownerWaitItemNumber(id) {
+  return OWNER_WAIT_ITEM_IDS.indexOf(id) + 1;
+}
+function decide(action, facts, mode, mayPublishNow = () => false) {
   void action;
   if (facts.some((f) => REFUSED_IN_EVERY_MODE.has(f.type)))
     return "refuse";
-  return mode === "questions-on" ? "ask" : "refuse";
+  switch (mode) {
+    case "questions-on":
+      return "ask";
+    case "questions-off":
+      return "refuse";
+    case "autonomous":
+      return decideAutonomous(facts, mayPublishNow);
+    default: {
+      const unhandled = mode;
+      void unhandled;
+      return "refuse";
+    }
+  }
+}
+function decideAutonomous(facts, mayPublishNow) {
+  if (facts.length === 0)
+    return { autonomous: "could-not-tell" };
+  const rows = [...facts].sort((a, b) => riskyTypeOrder(a.type) - riskyTypeOrder(b.type)).map((f) => autonomousRowOf(f.type));
+  if (rows.includes("never"))
+    return { autonomous: "never-under-autonomy" };
+  const firstWait = rows.find((r) => r === "wait-item-1" || r === "publish");
+  if (firstWait === "wait-item-1")
+    return { autonomous: "waits-for-owner", item: ownerWaitItemNumber("delete-users-data") };
+  if (firstWait === "publish" && !mayPublishNow()) {
+    return { autonomous: "waits-for-owner", item: ownerWaitItemNumber("publish-or-release") };
+  }
+  return rows.includes("save") ? { autonomous: "save-then-let-through" } : { autonomous: "let-through" };
 }
 
 // dist/risky/own-copy.js
-import { readFileSync as readFileSync18 } from "node:fs";
-import { join as join12, posix as posix2, win32 as win322 } from "node:path";
+import { readFileSync as readFileSync20 } from "node:fs";
+import { join as join13, posix as posix2, win32 as win322 } from "node:path";
 var OWN_COPY_START_TOOL = "Agent";
 var OWN_COPY_WRITE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
 var OWN_COPY_ISOLATION = "worktree";
@@ -28043,7 +29209,7 @@ function stringField2(o, key) {
 }
 function readOr(deps, path) {
   try {
-    return (deps.readFile ?? ((p) => readFileSync18(p, "utf-8")))(path);
+    return (deps.readFile ?? ((p) => readFileSync20(p, "utf-8")))(path);
   } catch {
     return null;
   }
@@ -28083,7 +29249,7 @@ function typeCanChangeFiles(subagentType, deps) {
     return true;
   if (AGENT_FILE_NAME.test(type)) {
     for (const base of [deps.projectDir, deps.home]) {
-      const text = readOr(deps, join12(base, ".claude", "agents", `${type}.md`));
+      const text = readOr(deps, join13(base, ".claude", "agents", `${type}.md`));
       if (text === null)
         continue;
       const tools = frontmatterTools(text);
@@ -28096,105 +29262,608 @@ function targetOf(call) {
   const t = call.toolInput;
   return call.toolName === "NotebookEdit" ? stringField2(t, "notebook_path") ?? stringField2(t, "file_path") : stringField2(t, "file_path");
 }
-function partOf(top, rel, p, deps) {
-  const text = readOr(deps, p.join(top, ...SYSTEM_DESCRIPTION_REL.split("/")));
-  if (text === null)
-    return null;
+function partOf(top, rel, p, deps) {
+  const text = readOr(deps, p.join(top, ...SYSTEM_DESCRIPTION_REL.split("/")));
+  if (text === null)
+    return null;
+  try {
+    const checked = checkSystemDescription(JSON.parse(text));
+    if (!checked.ok)
+      return null;
+    const owner = ownerOf(rel, checked.description);
+    return checked.description.parts.find((p2) => p2.id === owner)?.name ?? null;
+  } catch {
+    return null;
+  }
+}
+function isMainCopy(c) {
+  return c.top === c.main;
+}
+function judgeOwnCopy(input, call, deps) {
+  try {
+    if (call.toolName === OWN_COPY_START_TOOL)
+      return judgeStart(input, call, deps);
+    if (OWN_COPY_WRITE_TOOLS.has(call.toolName))
+      return judgeChange(input, call, deps);
+    return PASS;
+  } catch {
+    return PASS;
+  }
+}
+function judgeStart(input, call, deps) {
+  if (call.toolInput["isolation"] === OWN_COPY_ISOLATION)
+    return PASS;
+  if (!typeCanChangeFiles(call.toolInput["subagent_type"], deps))
+    return PASS;
+  const cwd = stringField2(input, "cwd");
+  if (cwd === null || whichCopy(cwd, deps.walk) === null)
+    return UNKNOWN;
+  const record2 = readLiveness(stringField2(input, "session_id"), cwd, deps.liveness);
+  if (!runsBesideOtherWork(call.toolInput, withoutAgent(record2, stringField2(input, "agent_id"))))
+    return PASS;
+  return { kind: "refused", facts: { type: "outside-own-copy", atStake: true, arm: "start" } };
+}
+function judgeChange(input, call, deps) {
+  const cwd = stringField2(input, "cwd");
+  const own = cwd === null ? null : whichCopy(cwd, deps.walk);
+  if (cwd === null || own === null)
+    return UNKNOWN;
+  const given = targetOf(call);
+  if (given === null)
+    return PASS;
+  const rules = deps.walk?.rules ?? machineRules();
+  const p = rules === "windows" ? win322 : posix2;
+  const place = copyHolding(given, deps.walk);
+  if (place === null || place.copy.common !== own.common)
+    return PASS;
+  const target = place.copy;
+  const agentId = stringField2(input, "agent_id");
+  let arm = null;
+  let record2;
+  const live = () => record2 === void 0 ? record2 = readLiveness(stringField2(input, "session_id"), cwd, deps.liveness) : record2;
+  if (agentId !== null) {
+    if (target.top !== own.top)
+      arm = "other-copy";
+    else {
+      const rec = live();
+      const mainTop = rec?.main?.top ?? (isMainCopy(own) ? own.top : null);
+      const others = withoutAgent(rec, agentId);
+      if (mainTop === own.top && others !== null && others.agents.length > 0)
+        arm = "main-copy-while-others";
+    }
+  } else if (target.top !== own.top && (live()?.agents ?? []).some((a) => a.top === target.top)) {
+    arm = "agents-copy";
+  }
+  if (arm === null)
+    return PASS;
+  const inFolder = place.folder.length > target.top.length ? place.folder.slice(target.top.length + 1) : "";
+  const rel = [inFolder, place.rest].filter((s) => s !== "").join(p.sep).split(p.sep).join("/");
+  return {
+    kind: "refused",
+    facts: {
+      type: "outside-own-copy",
+      atStake: true,
+      arm,
+      part: partOf(target.top, rel, p, deps),
+      file: rel,
+      ownPath: p.join(own.top, ...rel.split("/")),
+      ownIsMain: isMainCopy(own),
+      targetIsMain: isMainCopy(target)
+    }
+  };
+}
+
+// dist/risky/save.js
+import { randomBytes } from "node:crypto";
+import { chmodSync as chmodSync2, constants as fsConstants, copyFileSync, lstatSync as lstatSync3, mkdirSync as mkdirSync8, readdirSync as readdirSync9, readFileSync as readFileSync21, readlinkSync, realpathSync as realpathSync7, renameSync as renameSync10, rmSync as rmSync2, statSync as statSync8, symlinkSync, writeFileSync as writeFileSync12 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname7, isAbsolute as isAbsolute3, join as join14, resolve as resolve5 } from "node:path";
+var SAVE_LIMIT_BYTES = 2e8;
+var SAVE_BUDGET_MS = 5e3;
+function notSaved(reason) {
+  return { saved: false, reason };
+}
+function savedFolderOf(engagementId, home = homedir8()) {
+  if (!isEngagementId(engagementId))
+    return null;
+  return join14(home, HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, SAVED_DIR_NAME);
+}
+function saveFirst(staked, ctx) {
+  const now = ctx.now ?? Date.now;
+  const deadline = now() + (ctx.budgetMs ?? SAVE_BUDGET_MS);
+  const folder = savedFolderOf(ctx.engagementId, ctx.home);
+  if (folder === null)
+    return notSaved(AUTONOMY_SAVE_FAILED_REASON);
+  const plan = planOf(staked);
+  if (!plan.ok)
+    return notSaved(plan.reason);
+  const g = new SaveGit(plan.root, deadline, now);
+  const top = g.run(["rev-parse", "--show-toplevel"]);
+  if (!top.ok || realOrSelf2(top.value.trim()) !== plan.root)
+    return notSaved(AUTONOMY_SAVE_NOT_COVERED_REASON);
+  const head = g.run(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"]);
+  const headCommit2 = head.ok ? head.value.trim() : "";
+  if (!/^[0-9a-f]{40,64}$/.test(headCommit2))
+    return notSaved(AUTONOMY_SAVE_NO_HISTORY_REASON);
+  try {
+    pruneSaves(plan.root, ctx.engagementId, { ...ctx.home === void 0 ? {} : { home: ctx.home }, now, deadline });
+  } catch {
+  }
+  const found2 = filesOf(plan, g, deadline);
+  if (!found2.ok)
+    return notSaved(found2.reason);
+  let saveDir = null;
+  try {
+    const id = freshId(folder, ctx.newId);
+    if (id === null)
+      return notSaved(AUTONOMY_SAVE_FAILED_REASON);
+    saveDir = join14(folder, id);
+    const repository = repositoryOf(g);
+    if (repository === null)
+      return failed(saveDir);
+    writeFileSync12(join14(saveDir, SAVED_REPOSITORY_FILE_NAME), `${repository}
+`, { mode: 384 });
+    const privateIndex = join14(saveDir, PRIVATE_INDEX_NAME);
+    const commit = saveCommit(id, headCommit2, found2.tracked, plan.lines, privateIndex, g, now());
+    rmSync2(privateIndex, { force: true });
+    if (commit === null)
+      return failed(saveDir);
+    const copiesDir = join14(saveDir, SAVED_COPIES_DIR_NAME);
+    for (const rel of found2.copies) {
+      if (now() > deadline || !copyOne(join14(plan.root, rel), join14(copiesDir, rel)))
+        return failed(saveDir);
+    }
+    const description = savedSchema.safeParse({
+      id,
+      savedAt: new Date(now()).toISOString(),
+      ref: savedRefOf(id),
+      what: ctx.what.slice(0, 2e3),
+      paths: [
+        ...found2.tracked.map((path) => ({ path, keptIn: "commit" })),
+        ...found2.copies.map((path) => ({ path, keptIn: "copy" }))
+      ],
+      branches: plan.lines.filter((l) => l.name !== null).map((l) => ({ name: l.name, commit: l.commit }))
+    });
+    if (!description.success)
+      return failed(saveDir);
+    const file2 = join14(saveDir, SAVED_FILE_NAME);
+    writeFileSync12(`${file2}.part`, `${JSON.stringify(description.data, null, 2)}
+`, { mode: 384 });
+    renameSync10(`${file2}.part`, file2);
+    ctx.beforeRef?.();
+    const ref = g.run(["update-ref", "--no-deref", savedRefOf(id), commit, ""]);
+    if (!ref.ok)
+      return failed(saveDir);
+    return { saved: true, id, description: description.data };
+  } catch {
+    return saveDir === null ? notSaved(AUTONOMY_SAVE_FAILED_REASON) : failed(saveDir);
+  }
+}
+var PRIVATE_INDEX_NAME = "index.part";
+function failed(saveDir) {
+  try {
+    rmSync2(saveDir, { recursive: true, force: true });
+  } catch {
+  }
+  return notSaved(AUTONOMY_SAVE_FAILED_REASON);
+}
+function planOf(staked) {
+  if (staked.length === 0)
+    return { ok: false, reason: AUTONOMY_COULD_NOT_TELL_REASON };
+  let root = null;
+  const specs = [];
+  const lines2 = /* @__PURE__ */ new Map();
+  for (const f of staked) {
+    const t = f.save;
+    if (t === void 0)
+      return { ok: false, reason: f.cannotTell === void 0 ? AUTONOMY_SAVE_NOT_COVERED_REASON : AUTONOMY_COULD_NOT_TELL_REASON };
+    const r = realOrSelf2(resolve5(t.repoRoot));
+    if (root === null)
+      root = r;
+    else if (root !== r)
+      return { ok: false, reason: AUTONOMY_SAVE_NOT_COVERED_REASON };
+    for (const p of t.paths) {
+      if (!isInsideRel(p))
+        return { ok: false, reason: AUTONOMY_SAVE_NOT_COVERED_REASON };
+      specs.push(t.keep === void 0 ? { path: p } : { path: p, keep: t.keep });
+    }
+    for (const l of t.lines)
+      if (!lines2.has(l.commit) || l.name !== null)
+        lines2.set(l.commit, l);
+  }
+  return { ok: true, root, specs, lines: [...lines2.values()] };
+}
+function isInsideRel(p) {
+  if (p === ".")
+    return true;
+  if (p === "" || isAbsolute3(p) || p.includes("\\"))
+    return false;
+  return p.split("/").every((s) => s !== "" && s !== "." && s !== "..");
+}
+function under(rel, spec) {
+  return spec === "." || rel === spec || rel.startsWith(`${spec}/`);
+}
+function reached(rel, specs) {
+  return specs.some((s) => under(rel, s.path) && (s.keep === void 0 || s.keep(rel)));
+}
+function filesOf(plan, g, deadline) {
+  if (plan.specs.length === 0)
+    return { ok: true, tracked: [], copies: [] };
+  const specs = [...new Set(plan.specs.map((s) => s.path))];
+  const listed = g.run(["--literal-pathspecs", "ls-files", "-z", "--full-name", "--stage", "--", ...specs]);
+  if (!listed.ok)
+    return { ok: false, reason: AUTONOMY_SAVE_FAILED_REASON };
+  const trackedAll = /* @__PURE__ */ new Set();
+  const tracked = /* @__PURE__ */ new Set();
+  for (const rec of listed.value.split("\0")) {
+    const tab = rec.indexOf("	");
+    if (tab < 0)
+      continue;
+    const mode = rec.slice(0, rec.indexOf(" "));
+    const path = rec.slice(tab + 1);
+    if (mode === "160000")
+      continue;
+    trackedAll.add(path);
+    if (!reached(path, plan.specs))
+      continue;
+    const st = lstatOrNull(join14(plan.root, path));
+    if (st !== null && (st.isFile() || st.isSymbolicLink()))
+      tracked.add(path);
+  }
+  const copies = /* @__PURE__ */ new Set();
+  let bytes = 0;
+  let seen = 0;
+  const stack = [...specs];
+  while (stack.length > 0) {
+    const rel = stack.pop();
+    if (rel === ".git")
+      continue;
+    const abs = rel === "." ? plan.root : join14(plan.root, rel);
+    const st = lstatOrNull(abs);
+    if (st === null)
+      continue;
+    if (st.isDirectory()) {
+      let names;
+      try {
+        names = readdirSync9(abs);
+      } catch {
+        return { ok: false, reason: AUTONOMY_SAVE_FAILED_REASON };
+      }
+      for (const n of names) {
+        const child = rel === "." ? n : `${rel}/${n}`;
+        if (child !== ".git")
+          stack.push(child);
+      }
+    } else if ((st.isFile() || st.isSymbolicLink()) && !trackedAll.has(rel) && !copies.has(rel) && reached(rel, plan.specs)) {
+      copies.add(rel);
+      bytes += st.size;
+      if (bytes > SAVE_LIMIT_BYTES)
+        return { ok: false, reason: AUTONOMY_SAVE_TOO_LARGE_REASON };
+    }
+    if (++seen % 1024 === 0 && Date.now() > deadline)
+      return { ok: false, reason: AUTONOMY_SAVE_FAILED_REASON };
+  }
+  return { ok: true, tracked: [...tracked].sort(), copies: [...copies].sort() };
+}
+function copyOne(src, dst) {
+  const st = lstatOrNull(src);
+  if (st === null)
+    return false;
+  mkdirSync8(dirname7(dst), { recursive: true, mode: 448 });
+  if (st.isSymbolicLink()) {
+    symlinkSync(readlinkSync(src), dst);
+    return true;
+  }
+  copyFileSync(src, dst, fsConstants.COPYFILE_EXCL | fsConstants.COPYFILE_FICLONE);
+  chmodSync2(dst, st.mode & 4095);
+  return statSync8(dst).size === st.size;
+}
+function saveCommit(id, head, tracked, lines2, privateIndex, g, at) {
+  const indexPath = g.run(["rev-parse", "--git-path", "index"]);
+  if (!indexPath.ok)
+    return null;
+  const projectIndex = resolve5(g.root, indexPath.value.trim());
+  const env = commitEnv(privateIndex, at);
+  if (lstatOrNull(projectIndex) !== null)
+    copyFileSync(projectIndex, privateIndex);
+  else if (!g.run(["read-tree", head], env).ok)
+    return null;
+  const stagedTree = g.run(["write-tree"], env);
+  if (!stagedTree.ok)
+    return null;
+  const staged = g.run(["commit-tree", "--no-gpg-sign", stagedTree.value.trim(), "-p", head, "-m", `Halfcycle save ${id}: staged changes`], env);
+  if (!staged.ok)
+    return null;
+  if (tracked.length > 0 && !g.run(["update-index", "-z", "--stdin"], env, `${tracked.join("\0")}\0`).ok)
+    return null;
+  const tree = g.run(["write-tree"], env);
+  if (!tree.ok)
+    return null;
+  const parents = [.../* @__PURE__ */ new Set([head, staged.value.trim(), ...lines2.map((l) => l.commit)])];
+  const commit = g.run(["commit-tree", "--no-gpg-sign", tree.value.trim(), ...parents.flatMap((p) => ["-p", p]), "-m", `Halfcycle save ${id}`], env);
+  if (!commit.ok)
+    return null;
+  const sha = commit.value.trim();
+  return /^[0-9a-f]{40,64}$/.test(sha) ? sha : null;
+}
+function commitEnv(privateIndex, at) {
+  const date5 = `${String(Math.floor(at / 1e3))} +0000`;
+  return {
+    GIT_INDEX_FILE: privateIndex,
+    GIT_OPTIONAL_LOCKS: "0",
+    GIT_AUTHOR_NAME: "Halfcycle",
+    GIT_AUTHOR_EMAIL: "save@halfcycle.invalid",
+    GIT_AUTHOR_DATE: date5,
+    GIT_COMMITTER_NAME: "Halfcycle",
+    GIT_COMMITTER_EMAIL: "save@halfcycle.invalid",
+    GIT_COMMITTER_DATE: date5
+  };
+}
+var LONGEST_CAP_MS = 2147483647;
+function wholeMsLeft(ms) {
+  if (!(ms >= 1))
+    return null;
+  return Math.min(Math.floor(ms), LONGEST_CAP_MS);
+}
+var SaveGit = class {
+  root;
+  deadline;
+  now;
+  constructor(root, deadline, now) {
+    this.root = root;
+    this.deadline = deadline;
+    this.now = now;
+  }
+  run(args2, env, input) {
+    const left = wholeMsLeft(this.deadline - this.now());
+    if (left === null)
+      return { ok: false, message: "out of time" };
+    return gitForSave(args2, this.root, left, {
+      env: env ?? { GIT_OPTIONAL_LOCKS: "0" },
+      ...input === void 0 ? {} : { input }
+    });
+  }
+};
+function freshId(folder, newId) {
+  mkdirSync8(folder, { recursive: true, mode: 448 });
+  for (let i = 0; i < 5; i++) {
+    const id = newId?.() ?? defaultId();
+    if (!savedIdSchema.safeParse(id).success)
+      return null;
+    try {
+      mkdirSync8(join14(folder, id), { mode: 448 });
+      return id;
+    } catch (e) {
+      if (e.code !== "EEXIST")
+        return null;
+    }
+  }
+  return null;
+}
+function defaultId() {
+  const d = /* @__PURE__ */ new Date();
+  const two = (n) => String(n).padStart(2, "0");
+  const stamp = `${String(d.getUTCFullYear())}${two(d.getUTCMonth() + 1)}${two(d.getUTCDate())}-${two(d.getUTCHours())}${two(d.getUTCMinutes())}${two(d.getUTCSeconds())}`;
+  const rand = [...randomBytes(4)].map((b) => "abcdefghijklmnopqrstuvwxyz0123456789"[b % 36]).join("");
+  return `${stamp}-${rand}`;
+}
+function repositoryOf(g) {
+  const r = g.run(["rev-parse", "--git-common-dir"]);
+  if (!r.ok)
+    return null;
+  const dir = r.value.trim();
+  return dir === "" ? null : realOrSelf2(resolve5(g.root, dir));
+}
+function markedRepository(dir) {
+  try {
+    const text = readFileSync21(join14(dir, SAVED_REPOSITORY_FILE_NAME), "utf-8").trim();
+    return text === "" ? null : text;
+  } catch {
+    return null;
+  }
+}
+function pruneSaves(root, engagementId, ctx = {}) {
+  const folder = savedFolderOf(engagementId, ctx.home);
+  if (folder === null)
+    return;
+  const now = ctx.now ?? Date.now;
+  const g = new SaveGit(root, ctx.deadline ?? now() + SAVE_BUDGET_MS, now);
+  const listed = g.run(["for-each-ref", "--format=%(refname)%00%(committerdate:unix)", SAVED_REF_PREFIX]);
+  if (!listed.ok)
+    return;
+  const refs = /* @__PURE__ */ new Map();
+  for (const line2 of listed.value.split("\n")) {
+    const [name, when] = line2.split("\0");
+    if (name === void 0 || when === void 0 || !name.startsWith(SAVED_REF_PREFIX))
+      continue;
+    refs.set(name.slice(SAVED_REF_PREFIX.length), Number(when) * 1e3);
+  }
+  const repository = repositoryOf(g);
+  let names = [];
+  try {
+    names = readdirSync9(folder);
+  } catch {
+    names = [];
+  }
+  const here = /* @__PURE__ */ new Set();
+  for (const id of names) {
+    if (!savedIdSchema.safeParse(id).success)
+      continue;
+    here.add(id);
+    const dir = join14(folder, id);
+    const st = lstatOrNull(dir);
+    const answer = savedPruneAnswer({
+      refMadeAt: refs.get(id) ?? null,
+      folderChangedAt: st !== null && st.isDirectory() ? st.mtimeMs : null,
+      folderRepository: markedRepository(dir)
+    }, { repository, now: now() });
+    if (answer === "remove-folder")
+      rmSync2(dir, { recursive: true, force: true });
+    else if (answer === "remove-ref-then-folder" && g.run(["update-ref", "-d", savedRefOf(id)]).ok) {
+      rmSync2(dir, { recursive: true, force: true });
+    } else if (answer === "remove-ref")
+      g.run(["update-ref", "-d", savedRefOf(id)]);
+  }
+  for (const [id, madeAt] of refs) {
+    if (here.has(id) || !savedIdSchema.safeParse(id).success)
+      continue;
+    const answer = savedPruneAnswer({ refMadeAt: madeAt, folderChangedAt: null, folderRepository: null }, { repository, now: now() });
+    if (answer === "remove-ref")
+      g.run(["update-ref", "-d", savedRefOf(id)]);
+  }
+}
+function lstatOrNull(p) {
+  try {
+    return lstatSync3(p);
+  } catch {
+    return null;
+  }
+}
+function realOrSelf2(p) {
+  try {
+    return realpathSync7(p);
+  } catch {
+    return p;
+  }
+}
+
+// dist/autonomy-state.js
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync9, readFileSync as readFileSync22, renameSync as renameSync11, rmSync as rmSync3, writeFileSync as writeFileSync13 } from "node:fs";
+import { homedir as homedir9, platform as platform2 } from "node:os";
+import { dirname as dirname8, join as join15 } from "node:path";
+var AUTONOMY_STATE_FILENAME = "autonomy.json";
+var AUTONOMY_STATE_DEADLINE_MS = 1500;
+function autonomyStateFilePath(engagementId, home) {
+  return join15(home ?? homedir9(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, AUTONOMY_STATE_FILENAME);
+}
+function readCachedAutonomy(engagementId, nowMs, home) {
+  if (!isEngagementId(engagementId))
+    return null;
+  try {
+    const parsed = autonomyStateFileSchema.safeParse(JSON.parse(readFileSync22(autonomyStateFilePath(engagementId, home), "utf-8")));
+    if (!parsed.success || !parsed.data.on)
+      return null;
+    const age = nowMs - Date.parse(parsed.data.readAt);
+    return Number.isFinite(age) && age >= 0 && age < AUTONOMY_STATE_FILE_MAX_AGE_MS ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+function confirmMayPublishNow(opts) {
+  if (!isEngagementId(opts.engagementId) || CREDENTIAL_PLACEHOLDERS.includes(opts.bearer))
+    return false;
+  if (opts.timeoutMs <= 0)
+    return false;
+  try {
+    const url2 = `${opts.controlOrigin}/engagements/${encodeURIComponent(opts.engagementId)}/autonomy/state`;
+    const r = spawnSync2(process.execPath, ["--input-type=module", "-e", LIVE_READ_PROGRAM], {
+      input: JSON.stringify({ url: url2, bearer: opts.bearer, ms: Math.max(1, opts.timeoutMs - 250) }),
+      encoding: "utf-8",
+      timeout: opts.timeoutMs,
+      windowsHide: true
+    });
+    if (r.status !== 0 || typeof r.stdout !== "string")
+      return false;
+    const parsed = autonomyStateSchema.safeParse(JSON.parse(r.stdout));
+    return parsed.success && parsed.data.on && parsed.data.mayPublish;
+  } catch {
+    return false;
+  }
+}
+var LIVE_READ_PROGRAM = [
+  "let t='';process.stdin.setEncoding('utf8');",
+  "process.stdin.on('data',(c)=>{t+=c;});",
+  "process.stdin.on('end',async()=>{try{const o=JSON.parse(t);",
+  "const r=await fetch(o.url,{method:'GET',headers:{Authorization:'Bearer '+o.bearer},redirect:'manual',signal:AbortSignal.timeout(o.ms)});",
+  "if(r.status<200||r.status>299)process.exit(1);process.stdout.write(JSON.stringify(await r.json()));process.exit(0);",
+  "}catch{process.exit(1);}});"
+].join("");
+function deleteAutonomyStateFile(engagementId, home) {
   try {
-    const checked = checkSystemDescription(JSON.parse(text));
-    if (!checked.ok)
-      return null;
-    const owner = ownerOf(rel, checked.description);
-    return checked.description.parts.find((p2) => p2.id === owner)?.name ?? null;
+    rmSync3(autonomyStateFilePath(engagementId, home), { force: true });
   } catch {
-    return null;
   }
 }
-function isMainCopy(c) {
-  return c.top === c.main;
-}
-function judgeOwnCopy(input, call, deps) {
+function writeAutonomyStateFile(engagementId, file2, home) {
+  const target = autonomyStateFilePath(engagementId, home);
+  const temp = join15(dirname8(target), `.${AUTONOMY_STATE_FILENAME}.${process.pid}.tmp`);
   try {
-    if (call.toolName === OWN_COPY_START_TOOL)
-      return judgeStart(input, call, deps);
-    if (OWN_COPY_WRITE_TOOLS.has(call.toolName))
-      return judgeChange(input, call, deps);
-    return PASS;
+    mkdirSync9(dirname8(target), { recursive: true, mode: 448 });
+    writeFileSync13(temp, `${JSON.stringify(file2)}
+`, { mode: 384 });
+    if (platform2() !== "win32")
+      chmodSync3(temp, 384);
+    renameSync11(temp, target);
+    return true;
   } catch {
-    return PASS;
+    try {
+      rmSync3(temp, { force: true });
+    } catch {
+    }
+    return false;
   }
 }
-function judgeStart(input, call, deps) {
-  if (call.toolInput["isolation"] === OWN_COPY_ISOLATION)
-    return PASS;
-  if (!typeCanChangeFiles(call.toolInput["subagent_type"], deps))
-    return PASS;
-  const cwd = stringField2(input, "cwd");
-  if (cwd === null || whichCopy(cwd, deps.walk) === null)
-    return UNKNOWN;
-  const record2 = readLiveness(stringField2(input, "session_id"), cwd, deps.liveness);
-  if (!runsBesideOtherWork(call.toolInput, withoutAgent(record2, stringField2(input, "agent_id"))))
-    return PASS;
-  return { kind: "refused", facts: { type: "outside-own-copy", atStake: true, arm: "start" } };
+async function readAutonomyStateFromControl(opts) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), opts.deadlineMs);
+  try {
+    const url2 = `${opts.controlOrigin}/engagements/${encodeURIComponent(opts.engagementId)}/autonomy/state`;
+    const res = await opts.fetchFn(url2, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${opts.bearer}` },
+      redirect: "manual",
+      signal: controller.signal
+    });
+    if (res.status < 200 || res.status > 299)
+      return void 0;
+    const parsed = autonomyStateSchema.safeParse(await res.json());
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
 }
-function judgeChange(input, call, deps) {
-  const cwd = stringField2(input, "cwd");
-  const own = cwd === null ? null : whichCopy(cwd, deps.walk);
-  if (cwd === null || own === null)
-    return UNKNOWN;
-  const given = targetOf(call);
-  if (given === null)
-    return PASS;
-  const rules = deps.walk?.rules ?? machineRules();
-  const p = rules === "windows" ? win322 : posix2;
-  const place = copyHolding(given, deps.walk);
-  if (place === null || place.copy.common !== own.common)
-    return PASS;
-  const target = place.copy;
-  const agentId = stringField2(input, "agent_id");
-  let arm = null;
-  let record2;
-  const live = () => record2 === void 0 ? record2 = readLiveness(stringField2(input, "session_id"), cwd, deps.liveness) : record2;
-  if (agentId !== null) {
-    if (target.top !== own.top)
-      arm = "other-copy";
-    else {
-      const rec = live();
-      const mainTop = rec?.main?.top ?? (isMainCopy(own) ? own.top : null);
-      const others = withoutAgent(rec, agentId);
-      if (mainTop === own.top && others !== null && others.agents.length > 0)
-        arm = "main-copy-while-others";
-    }
-  } else if (target.top !== own.top && (live()?.agents ?? []).some((a) => a.top === target.top)) {
-    arm = "agents-copy";
+async function cacheAutonomySetting(opts) {
+  const { engagementId, home } = opts;
+  if (!isEngagementId(engagementId))
+    return;
+  const bearer = opts.bearer;
+  const usable = bearer !== void 0 && !CREDENTIAL_PLACEHOLDERS.includes(bearer) && opts.deadlineMs > 0;
+  const state = usable ? await readAutonomyStateFromControl({
+    controlOrigin: opts.controlOrigin,
+    engagementId,
+    bearer,
+    fetchFn: opts.fetchFn,
+    deadlineMs: opts.deadlineMs
+  }) : void 0;
+  if (state === void 0) {
+    deleteAutonomyStateFile(engagementId, home);
+    return;
+  }
+  const file2 = autonomyStateFileSchema.safeParse({ ...state, readAt: (/* @__PURE__ */ new Date()).toISOString() });
+  if (!file2.success || !writeAutonomyStateFile(engagementId, file2.data, home)) {
+    deleteAutonomyStateFile(engagementId, home);
   }
-  if (arm === null)
-    return PASS;
-  const inFolder = place.folder.length > target.top.length ? place.folder.slice(target.top.length + 1) : "";
-  const rel = [inFolder, place.rest].filter((s) => s !== "").join(p.sep).split(p.sep).join("/");
-  return {
-    kind: "refused",
-    facts: {
-      type: "outside-own-copy",
-      atStake: true,
-      arm,
-      part: partOf(target.top, rel, p, deps),
-      file: rel,
-      ownPath: p.join(own.top, ...rel.split("/")),
-      ownIsMain: isMainCopy(own),
-      targetIsMain: isMainCopy(target)
-    }
-  };
 }
 
 // dist/hooks/pre-tool-use.js
-import { homedir as homedir8 } from "node:os";
+import { performance } from "node:perf_hooks";
+import { homedir as homedir10 } from "node:os";
 var UNREADABLE_INPUT_NOTICE = "Halfcycle could not read what the coding agent was about to do, so that step went ahead without being checked for anything that cannot be undone. If this keeps happening, update Halfcycle.";
+var PRE_TOOL_USE_LIMIT_MS = (HALFCYCLE_HOOK_WIRING.find((e) => e.event === "PreToolUse")?.timeout ?? 10) * 1e3;
+var AUTONOMY_REPLY_MARGIN_MS = 1e3;
+var MAY_PUBLISH_READ_MS = 3e3;
 var OWN_COPY_UNKNOWN_NOTICE = "Halfcycle could not tell which copy of the project this agent works in, so it let the step go ahead without checking that it stays in its own copy.";
 var CHECKED = new Set(CHECKED_TOOLS);
+var RECORDED_ONLY = new Set(RECORDED_ONLY_TOOLS);
 function runPreToolUse(deps) {
   const input = parseObject(deps.input);
-  recordTimeEvent("action", input ?? {}, deps);
+  const at = clockOf(deps)();
+  const stamped = { ...deps, now: () => at };
+  recordTimeEvent("action", input ?? {}, stamped);
+  recordOwnShell(input, at, { ...deps.liveness?.dir === void 0 ? {} : { dir: deps.liveness.dir } });
   const seen = recordLiveness(input ?? {}, deps.liveness);
   const paceDeps = {
     ...deps.pace ?? {},
@@ -28204,6 +29873,10 @@ function runPreToolUse(deps) {
   };
   if (seen?.firstSeen === true && input !== null && typeof input["agent_id"] === "string")
     retirePendingStart(input, paceDeps);
+  const { mode, autonomy } = answerModeOf(input, deps, at);
+  const toolName = input === null ? void 0 : stringOf(input, "tool_name");
+  if (toolName !== void 0 && RECORDED_ONLY.has(toolName))
+    return recordedOnlyReply(mode);
   const call = input === null ? null : toolCallOf(input);
   if (call === null || !CHECKED.has(call.toolName))
     return unreadable(deps, input);
@@ -28226,7 +29899,6 @@ function runPreToolUse(deps) {
   }
   const own = ownCopyOf(input, call, deps);
   try {
-    const mode = answerModeFor(input["permission_mode"]);
     if (own.kind === "refused") {
       const staked = [...answer.silent ? [] : answer.staked, own.facts];
       if (decide(call, staked, mode) === "refuse") {
@@ -28235,6 +29907,11 @@ function runPreToolUse(deps) {
 `;
       }
     }
+    if (mode === "autonomous") {
+      const sendsSaves = call.toolName === "Bash" && typeof call.toolInput["command"] === "string" && pushesSavedRefs(call.toolInput["command"]);
+      if (!answer.silent || sendsSaves)
+        return autonomousReply(call, answer.silent ? [] : answer.staked, sendsSaves, mode, autonomy, deps);
+    }
     if (answer.silent) {
       if (call.toolName === PACE_HELD_TOOL) {
         const held = paceHoldText(input, call.toolInput, paceDeps);
@@ -28255,12 +29932,100 @@ function runPreToolUse(deps) {
     return "";
   }
 }
+function clockOf(deps) {
+  return deps.now ?? (() => /* @__PURE__ */ new Date());
+}
+function answerModeOf(input, deps, at) {
+  const engagementId = readConfig(deps.env ?? process.env).config?.guardEngagementId;
+  const cached2 = engagementId === void 0 ? null : readCachedAutonomy(engagementId, at.getTime(), deps.home);
+  if (engagementId !== void 0 && cached2 !== null)
+    return { mode: "autonomous", autonomy: { engagementId, mayPublish: cached2.mayPublish } };
+  return { mode: answerModeFor(input === null ? void 0 : input["permission_mode"]), autonomy: null };
+}
+function autonomousReply(call, staked, sendsSaves, mode, autonomy, deps) {
+  try {
+    return autonomousAnswer(call, staked, sendsSaves, mode, autonomy, deps);
+  } catch {
+    return `${preToolUseReplyText("refuse", autonomyA12(typeSentenceFor(staked, sendsSaves), AUTONOMY_SAVE_FAILED_REASON))}
+`;
+  }
+}
+function autonomousAnswer(call, staked, sendsSaves, mode, autonomy, deps) {
+  const startedAt = deps.autonomy?.startedAtMs ?? performance.timeOrigin;
+  const left = () => Math.floor(startedAt + PRE_TOOL_USE_LIMIT_MS - AUTONOMY_REPLY_MARGIN_MS - Date.now());
+  const mayPublishNow = () => {
+    if (!autonomy.mayPublish)
+      return false;
+    if (deps.autonomy?.mayPublishNow !== void 0)
+      return deps.autonomy.mayPublishNow();
+    const env = deps.env ?? process.env;
+    const config2 = readConfig(env).config;
+    if (config2 === null)
+      return false;
+    return confirmMayPublishNow({
+      controlOrigin: readControlOrigin(env).origin,
+      engagementId: autonomy.engagementId,
+      bearer: config2.guardServiceToken,
+      timeoutMs: Math.min(MAY_PUBLISH_READ_MS, left())
+    });
+  };
+  const decided = decide(call, sendsSaves ? [...staked, { type: "rewrite-shared-history" }] : staked, mode, mayPublishNow);
+  const refuse = (text) => `${preToolUseReplyText("refuse", text)}
+`;
+  if (decided === "ask" || decided === "refuse")
+    return refuse(autonomyA12(typeSentenceFor([]), AUTONOMY_COULD_NOT_TELL_REASON));
+  switch (decided.autonomous) {
+    case "waits-for-owner":
+      return refuse(autonomyA10(typeSentenceFor(staked, sendsSaves), decided.item));
+    case "never-under-autonomy":
+      return refuse(autonomyA11(typeSentenceFor(staked, sendsSaves)));
+    case "could-not-tell":
+      return refuse(autonomyA12(typeSentenceFor([]), AUTONOMY_COULD_NOT_TELL_REASON));
+    case "let-through":
+      return "";
+    case "save-then-let-through": {
+      const kept = staked.filter((f) => savedByAutonomy(f.type));
+      const what = savedWhatFor(kept);
+      const budgetMs = Math.min(SAVE_BUDGET_MS, left());
+      const saved = budgetMs <= 0 ? { saved: false, reason: AUTONOMY_SAVE_FAILED_REASON } : saveFirst(kept, {
+        engagementId: autonomy.engagementId,
+        what,
+        budgetMs,
+        ...deps.home === void 0 ? {} : { home: deps.home },
+        ...deps.autonomy?.newId === void 0 ? {} : { newId: deps.autonomy.newId },
+        ...deps.autonomy?.beforeRef === void 0 ? {} : { beforeRef: deps.autonomy.beforeRef }
+      });
+      if (!saved.saved)
+        return refuse(autonomyA12(typeSentenceFor(saved.reason === AUTONOMY_COULD_NOT_TELL_REASON ? [] : staked), saved.reason));
+      return `${preToolUseSavedText(autonomyA9(what, saved.id))}
+`;
+    }
+    default: {
+      const unhandled = decided;
+      return unhandled;
+    }
+  }
+}
+function recordedOnlyReply(mode) {
+  switch (mode) {
+    case "questions-on":
+    case "questions-off":
+      return "";
+    case "autonomous":
+      return `${preToolUseReplyText("refuse", AUTONOMY_A18)}
+`;
+    default: {
+      const unhandled = mode;
+      return unhandled;
+    }
+  }
+}
 function ownCopyOf(input, call, deps) {
   try {
     const walk2 = deps.walk ?? deps.liveness?.walk;
     return judgeOwnCopy(input, call, {
       projectDir: deps.projectDir ?? projectFolder(deps.env ?? process.env),
-      home: deps.home ?? homedir8(),
+      home: deps.home ?? homedir10(),
       ...walk2 === void 0 ? {} : { walk: walk2 },
       ...deps.liveness === void 0 ? {} : { liveness: deps.liveness }
     });
@@ -28300,6 +30065,8 @@ function unreadable(deps, input) {
 }
 
 // dist/hooks/session-diff.js
+import { unlinkSync as unlinkSync9 } from "node:fs";
+import { join as join16 } from "node:path";
 var STOP_HOOK_EVENT = {
   stop: "Stop",
   "subagent-stop": "SubagentStop"
@@ -28351,6 +30118,7 @@ async function evaluateSession(input, kind, reply, readSeat) {
   }
   const repoRoot = repoRootResult.value;
   const sessionId = input.session_id;
+  const folder = realPathOf(repoRoot);
   orphanSweep(repoRoot, (ref) => refExists(ref, repoRoot), sessionId, Date.now(), whichCopy(process.cwd())?.common ?? null);
   const base = resolveDiffBase2(repoRoot, sessionId);
   const diffBase = base.kind;
@@ -28359,9 +30127,16 @@ async function evaluateSession(input, kind, reply, readSeat) {
     reply.notice(localFaultText(`Could not get session diff: ${collected.message}`));
     return;
   }
-  const { getDiff } = collected;
-  const { evaluated: changedFiles2 } = partitionInstallerOutput(collected.files);
+  const tracked = new Set(collected.files);
+  const candidates = ownEditedFiles(repoRoot, sessionId).filter((relPath) => !tracked.has(relPath));
+  const untracked = getUntrackedFiles(repoRoot, candidates);
+  const created = untracked.ok ? untracked.value.filter((relPath) => !tracked.has(relPath)) : [];
+  const getDiff = (relPath) => tracked.has(relPath) ? collected.getDiff(relPath) : getSingleFileDiff(join16(repoRoot, relPath), repoRoot);
+  const { evaluated } = partitionInstallerOutput(collected.files);
+  const { evaluated: createdEvaluated } = partitionInstallerOutput(created);
+  const changedFiles2 = [...ownChangedFiles(repoRoot, evaluated, sessionId), ...createdEvaluated];
   if (changedFiles2.length === 0) {
+    queueTurnEnd(keepBooks(sessionId, folder, { kind: "no-own-changes" }, kind === "stop"), reply);
     return;
   }
   const fileDiffEntries = changedFiles2.map((relPath) => ({
@@ -28372,6 +30147,7 @@ async function evaluateSession(input, kind, reply, readSeat) {
   const digest = digestChangeState(baseKey, fileDiffEntries);
   const prior = readDedupe(repoRoot, sessionId);
   if (prior && prior.base === baseKey && prior.digest === digest) {
+    queueTurnEnd(keepBooks(sessionId, folder, { kind: "unchanged" }, kind === "stop"), reply);
     return;
   }
   const context = loadChangeSetContext(repoRoot);
@@ -28450,30 +30226,56 @@ async function evaluateSession(input, kind, reply, readSeat) {
     warn: (msg) => process.stderr.write(msg + "\n")
   });
   writeDedupe(repoRoot, sessionId, { base: baseKey, digest });
-  actOnEnvelope3(clientResult.envelope, kind, input.stop_hook_active === true, reply);
+  actOnEnvelope3(clientResult.envelope, kind, input.stop_hook_active === true, reply, sessionId, folder);
+}
+function keepBooks(sessionId, folder, outcome, topLevel) {
+  const books = () => {
+    const before = readFindings(sessionId);
+    const { file: file2, news } = turnEndBookkeeping(before ?? emptyFindings(""), folder, outcome, topLevel, /* @__PURE__ */ new Date());
+    if (before !== null && JSON.stringify(before) !== JSON.stringify(file2)) {
+      if (file2.findings.length > 0)
+        writeFindings(file2);
+      else
+        removeFindingsFile(sessionId);
+    }
+    return turnEndMessage(news);
+  };
+  const locked = withFindingsLock(sessionId, books);
+  return locked === void 0 ? books() : locked;
 }
-function actOnEnvelope3(envelope, kind, neverBlock, reply) {
-  const notRun = notRunReport(envelope.notRun);
-  const notRunBlock = notRun ? `
-${notRun}` : "";
-  if (envelope.guardsFired.length === 0) {
-    if (notRun)
-      reply.notice(notRun);
+function removeFindingsFile(sessionId) {
+  const path = findingsPath(sessionId);
+  if (path === null)
     return;
+  try {
+    unlinkSync9(path);
+  } catch {
   }
-  const where = kind === "stop" ? "session stop" : "session stop";
-  const guardLines = envelope.guardsFired.map((g) => `  [${g.severity.toUpperCase()}] ${g.patternRef}: ${g.explanation}`).join("\n");
+}
+function queueTurnEnd(words, reply) {
+  if (words !== null)
+    reply.notice(words);
+}
+function actOnEnvelope3(envelope, kind, neverBlock, reply, sessionId, folder) {
+  const notRun = notRunMessage((envelope.notRun ?? []).map((n) => n.reason));
+  const outcome = {
+    kind: "evaluated",
+    fired: envelope.guardsFired,
+    notRun: (envelope.notRun ?? []).map((n) => n.patternRef)
+  };
+  const topLevel = kind === "stop";
   if (envelope.blocking && !neverBlock) {
-    reply.block(`Guard blocked at ${where}: ${envelope.explanation}
-${guardLines}${notRunBlock}`);
-  } else if (envelope.blocking && neverBlock) {
-    reply.notice(`[Halfcycle] Guard would block at ${where} but the stop was already continued (stop_hook_active) \u2014 surfacing as a warning:
-${envelope.explanation}
-${guardLines}${notRunBlock}`);
-  } else {
-    reply.notice(`[Halfcycle] Guard warning at ${where}: ${envelope.explanation}
-${guardLines}${notRunBlock}`);
+    keepBooks(sessionId, folder, outcome, false);
+    const reason = blockReason(envelope.guardsFired.map((g) => g.explanation));
+    reply.block(notRun ? `${reason}
+${notRun}` : reason, stoppedMessage(blockingExplanations(envelope.guardsFired)));
+  }
+  if (envelope.blocking && neverBlock) {
+    reply.notice(couldNotFixMessage(blockingExplanations(envelope.guardsFired)));
   }
+  queueTurnEnd(keepBooks(sessionId, folder, outcome, topLevel), reply);
+  if (notRun)
+    reply.notice(notRun);
 }
 
 // dist/hooks/stdin.js
@@ -28492,9 +30294,9 @@ async function readHookStdin() {
   }
 }
 function readStdin2() {
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     if (process.stdin.isTTY) {
-      resolve6("");
+      resolve8("");
       return;
     }
     const chunks = [];
@@ -28504,7 +30306,7 @@ function readStdin2() {
         return;
       settled = true;
       clearTimeout(timer);
-      resolve6(Buffer.concat(chunks).toString("utf-8"));
+      resolve8(Buffer.concat(chunks).toString("utf-8"));
     };
     const timer = setTimeout(done, HOOK_STDIN_GRACE_MS);
     process.stdin.on("data", (chunk) => chunks.push(chunk));
@@ -28584,6 +30386,22 @@ function matchScopePhraseShape(shape, shown2) {
   return { kind: "show-first", act: "send-back" };
 }
 
+// dist/hooks/autonomy-phrase.js
+var AUTONOMY_ON = /^autonomy on$/i;
+var AUTONOMY_OFF = /^autonomy off$/i;
+function autonomyPhraseShape(prompt) {
+  if (typeof prompt !== "string")
+    return null;
+  const line2 = prompt.trim();
+  if (LINE_BREAK.test(line2))
+    return null;
+  if (AUTONOMY_ON.test(line2))
+    return "on";
+  if (AUTONOMY_OFF.test(line2))
+    return "off";
+  return null;
+}
+
 // dist/hooks/review-phrase.js
 var VERBS = [
   [/^accept /i, "accept"],
@@ -28650,20 +30468,20 @@ function matchReviewPhraseShape(shape, reviews) {
 }
 
 // dist/hooks/shown-record.js
-import { chmodSync as chmodSync2, readFileSync as readFileSync19, renameSync as renameSync9, unlinkSync as unlinkSync8, writeFileSync as writeFileSync11 } from "node:fs";
-import { homedir as homedir9, platform as platform2 } from "node:os";
-import { join as join13 } from "node:path";
+import { chmodSync as chmodSync4, readFileSync as readFileSync23, renameSync as renameSync12, unlinkSync as unlinkSync10, writeFileSync as writeFileSync14 } from "node:fs";
+import { homedir as homedir11, platform as platform3 } from "node:os";
+import { join as join17 } from "node:path";
 function recordDir(engagementId, home) {
   if (!isEngagementId(engagementId))
     return null;
-  return join13(home ?? homedir9(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId);
+  return join17(home ?? homedir11(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId);
 }
 function readShownRecord(engagementId, home) {
   const dir = recordDir(engagementId, home);
   if (dir === null)
     return { entries: [], reviews: [] };
   try {
-    return parseShownRecord(readFileSync19(join13(dir, SHOWN_PLANS_FILENAME), "utf-8"));
+    return parseShownRecord(readFileSync23(join17(dir, SHOWN_PLANS_FILENAME), "utf-8"));
   } catch {
     return { entries: [], reviews: [] };
   }
@@ -28684,24 +30502,24 @@ function moveListedReviewForward(engagementId, home, listed, reviewVersion, deci
     const dir = recordDir(engagementId, home);
     if (dir === null)
       return false;
-    const path = join13(dir, SHOWN_PLANS_FILENAME);
-    const current = parseShownRecord(readFileSync19(path, "utf-8"));
+    const path = join17(dir, SHOWN_PLANS_FILENAME);
+    const current = parseShownRecord(readFileSync23(path, "utf-8"));
     const at = current.reviews.findIndex((r) => r.phase === listed.phase && r.shownAt === listed.shownAt && r.reviewVersion === listed.reviewVersion);
     if (at === -1)
       return false;
     const acts = new Map(decided.map((d) => [d.part, d.act]));
     const reviews = current.reviews.map((review, i) => i === at ? { ...review, reviewVersion, parts: review.parts.map((p) => movedPart(p, acts.get(p.part))) } : review);
     const body = serialiseShownRecord({ entries: current.entries, reviews });
-    temp = join13(dir, `.${SHOWN_PLANS_FILENAME}.${process.pid}.tmp`);
-    writeFileSync11(temp, body, { mode: 384 });
-    if (platform2() !== "win32")
-      chmodSync2(temp, 384);
-    renameSync9(temp, path);
+    temp = join17(dir, `.${SHOWN_PLANS_FILENAME}.${process.pid}.tmp`);
+    writeFileSync14(temp, body, { mode: 384 });
+    if (platform3() !== "win32")
+      chmodSync4(temp, 384);
+    renameSync12(temp, path);
     return true;
   } catch {
     if (temp !== null) {
       try {
-        unlinkSync8(temp);
+        unlinkSync10(temp);
       } catch {
         return false;
       }
@@ -28996,15 +30814,59 @@ function reviewLineForAnswer(context, answer) {
     }
   }
 }
+var AUTONOMY_NOTHING_CHANGED = "Nothing changed";
+function autonomyNotAttendedLine() {
+  return line(`${AUTONOMY_NOTHING_CHANGED}: turning this on or off by typing counts only when a person types it into an open session.`);
+}
+function autonomyNotSignedInLine() {
+  return line(`${AUTONOMY_NOTHING_CHANGED}: this project is not signed in on this computer. ${HOOK_REMEDY}`);
+}
+function autonomyNotOwnerLine() {
+  return line(`${AUTONOMY_NOTHING_CHANGED}: only the project's owner can turn this on or off.`);
+}
+function autonomyNoOwnerLine() {
+  return line(`${AUTONOMY_NOTHING_CHANGED}: this project has no owner, so nobody can turn this on or off.`);
+}
+function autonomyNotOfferedLine() {
+  return line(`${AUTONOMY_NOTHING_CHANGED}. ${TYPED_APPROVAL_OFF_SENTENCE}`);
+}
+function autonomyCannotReachLine() {
+  return line(`${AUTONOMY_NOTHING_CHANGED}: Halfcycle could not be reached just now. Type the line again in a minute.`);
+}
+function autonomyLineForAnswer(answer) {
+  switch (answer.outcome) {
+    case "recorded":
+      return line(answer.on ? AUTONOMY_A4 : AUTONOMY_A5);
+    case "not-owner":
+      return autonomyNotOwnerLine();
+    case "no-owner":
+      return autonomyNoOwnerLine();
+    case "not-offered":
+      return autonomyNotOfferedLine();
+    case "unavailable":
+      return autonomyCannotReachLine();
+    default: {
+      const unreachable = answer;
+      return unreachable;
+    }
+  }
+}
 
 // dist/hooks/user-prompt-submit.js
 var CHAT_REQUEST_TIMEOUT_MS = 6e3;
 var SHOWN_ENTRY_MAX_AGE_MS = 60 * 60 * 1e3;
 async function runUserPromptSubmit(opts) {
   let act = null;
+  let autonomyAct = null;
   const review = { recognised: false };
   try {
     const prompt = promptOf(opts.input);
+    const autonomyShape = autonomyPhraseShape(prompt);
+    if (autonomyShape !== null) {
+      autonomyAct = autonomyShape;
+      return `${await decideAutonomy(autonomyShape, opts)}
+`;
+    }
     const reviewShape = reviewPhraseShape(prompt);
     if (reviewShape !== null) {
       const out = await decideReview(reviewShape, opts, review);
@@ -29018,6 +30880,9 @@ async function runUserPromptSubmit(opts) {
     return `${await decide2(shape, opts)}
 `;
   } catch {
+    if (autonomyAct !== null)
+      return `${autonomyCannotReachLine()}
+`;
     if (review.recognised)
       return `${reviewCannotReachLine()}
 `;
@@ -29025,6 +30890,44 @@ async function runUserPromptSubmit(opts) {
 `;
   }
 }
+async function decideAutonomy(act, opts) {
+  const env = opts.env ?? process.env;
+  if (!readSessionAttended(env))
+    return autonomyNotAttendedLine();
+  const read = readConfig(env);
+  if (read.config === null) {
+    return readNeverConfiguredReason(env) === "not-this-account" ? autonomyNotOwnerLine() : autonomyNotSignedInLine();
+  }
+  const { guardServiceToken, guardEngagementId } = read.config;
+  return postAutonomy(act, guardEngagementId, guardServiceToken, env, opts.fetchFn);
+}
+async function postAutonomy(act, engagementId, credential, env, fetchFn = globalThis.fetch) {
+  const url2 = `${readControlOrigin(env).origin}/engagements/${encodeURIComponent(engagementId)}/autonomy/chat`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), CHAT_REQUEST_TIMEOUT_MS);
+  try {
+    const response = await fetchFn(url2, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${credential}`, "Content-Type": "application/json" },
+      body: JSON.stringify(autonomyChatRequestSchema.parse({ act })),
+      signal: controller.signal
+    });
+    if (response.status === 401)
+      return autonomyNotSignedInLine();
+    if (response.status === 429 || response.status >= 500)
+      return autonomyCannotReachLine();
+    const parsed = autonomyChatResultSchema.safeParse(await response.json());
+    if (!parsed.success)
+      return autonomyCannotReachLine();
+    if (parsed.data.outcome === "recorded" && response.status !== 200)
+      return autonomyCannotReachLine();
+    return autonomyLineForAnswer(parsed.data);
+  } catch {
+    return autonomyCannotReachLine();
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function decideReview(shape, opts, progress) {
   const env = opts.env ?? process.env;
   if (shape.kind === "phase") {
@@ -29206,18 +31109,36 @@ async function post(act, entry, request, engagementId, credential, env, fetchFn
   }
 }
 
+// dist/hooks/user-prompt-findings.js
+function runUserPromptFindings(opts) {
+  try {
+    const parsed = JSON.parse(opts.input);
+    if (typeof parsed !== "object" || parsed === null)
+      return "";
+    const sessionId = parsed["session_id"];
+    const given = deliverFindings(sessionId, null);
+    if (given.length === 0)
+      return "";
+    const project = realPathOf(projectFolder(opts.env ?? process.env));
+    return `${userPromptContextReply(detailsBlock(given, project))}
+`;
+  } catch {
+    return "";
+  }
+}
+
 // dist/resolve-engagement.js
-import { existsSync as existsSync7, readFileSync as readFileSync20, realpathSync as realpathSync6 } from "node:fs";
-import { join as join14, sep as sep3 } from "node:path";
-import { homedir as homedir10 } from "node:os";
+import { existsSync as existsSync8, readFileSync as readFileSync24, realpathSync as realpathSync8 } from "node:fs";
+import { join as join18, sep as sep4 } from "node:path";
+import { homedir as homedir12 } from "node:os";
 function defaultRegistryPath() {
-  return join14(homedir10(), ".halfcycle", "registry.json");
+  return join18(homedir12(), ".halfcycle", "registry.json");
 }
 function readRegistry(registryPath = defaultRegistryPath()) {
-  if (!existsSync7(registryPath))
+  if (!existsSync8(registryPath))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync20(registryPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync24(registryPath, "utf-8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
     const out = {};
@@ -29232,7 +31153,7 @@ function readRegistry(registryPath = defaultRegistryPath()) {
 }
 function canonicalise(p) {
   try {
-    return realpathSync6(p);
+    return realpathSync8(p);
   } catch {
     return p;
   }
@@ -29253,7 +31174,7 @@ function resolveEngagement(cwd, registry2) {
 function isSelfOrAncestor(ancestor, target) {
   if (ancestor === target)
     return true;
-  const withSep = ancestor.endsWith(sep3) ? ancestor : ancestor + sep3;
+  const withSep = ancestor.endsWith(sep4) ? ancestor : ancestor + sep4;
   return target.startsWith(withSep);
 }
 function runResolveEngagement(cwd, registryPath) {
@@ -29265,13 +31186,13 @@ function runResolveEngagement(cwd, registryPath) {
 }
 
 // dist/refresh-credential.js
-import { readFileSync as readFileSync22 } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { readFileSync as readFileSync26 } from "node:fs";
+import { resolve as resolve7 } from "node:path";
 
 // dist/mcp-headers.js
-import { readFileSync as readFileSync21 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { dirname as dirname6, resolve as resolve4 } from "node:path";
+import { readFileSync as readFileSync25 } from "node:fs";
+import { homedir as homedir13 } from "node:os";
+import { dirname as dirname9, resolve as resolve6 } from "node:path";
 function defaultWriteErr(text) {
   process.stderr.write(text);
 }
@@ -29284,12 +31205,12 @@ function headerLine(bearer, clientVersion) {
 }
 function projectRootFromBinary(binaryPath) {
   const depth = VENDORED_BIN_REL.split("/").length - 1;
-  return resolve4(dirname6(binaryPath), ...Array(depth).fill(".."));
+  return resolve6(dirname9(binaryPath), ...Array(depth).fill(".."));
 }
 function readPinnedVersion(root) {
   let raw;
   try {
-    raw = readFileSync21(resolve4(root, BUNDLE_PIN_REL), "utf-8");
+    raw = readFileSync25(resolve6(root, BUNDLE_PIN_REL), "utf-8");
   } catch {
     return void 0;
   }
@@ -29331,7 +31252,7 @@ function sentences(lines2) {
 }
 function badIdSentence(root) {
   return sentences([
-    `${resolve4(root, BUNDLE_PIN_REL)} names an engagement id that is not a Halfcycle project id,`,
+    `${resolve6(root, BUNDLE_PIN_REL)} names an engagement id that is not a Halfcycle project id,`,
     'so no credential was read. Delete that file and run "npx halfcycle" again: this repository',
     "is then set up as a new Halfcycle project."
   ]);
@@ -29345,7 +31266,7 @@ function storeProblemSentence(problem, root, home, engagementId) {
       ]);
     case "no-id":
       return sentences([
-        `${resolve4(root, BUNDLE_PIN_REL)} names no engagement id.`,
+        `${resolve6(root, BUNDLE_PIN_REL)} names no engagement id.`,
         'run "npx halfcycle" here to rewrite it.'
       ]);
     case "bad-id":
@@ -29362,7 +31283,7 @@ function storeProblemSentence(problem, root, home, engagementId) {
     case "no-credential":
       return sentences([
         `this machine holds no credential for engagement ${engagementId ?? ""}.`,
-        `run "npx halfcycle" in this repository \u2014 it will sign you in through your browser if needed, and write the credential to ${resolve4(home, HALFCYCLE_DIR_NAME)}, outside this repository.`
+        `run "npx halfcycle" in this repository \u2014 it will sign you in through your browser if needed, and write the credential to ${resolve6(home, HALFCYCLE_DIR_NAME)}, outside this repository.`
       ]);
   }
 }
@@ -29385,7 +31306,7 @@ async function refreshWithinDeadline(source, opts, writeErr) {
 }
 async function chooseBearer(opts) {
   const writeErr = opts.writeErr ?? defaultWriteErr;
-  const home = opts.home ?? homedir11();
+  const home = opts.home ?? homedir13();
   const root = projectRootFromBinary(opts.binaryPath);
   const environmentToken = opts.environmentTokenFirst ? readEnvironmentToken() : void 0;
   const store = resolveStore(root, home);
@@ -29512,10 +31433,11 @@ async function refreshCredentialToken(opts) {
 var CHECKED_SOURCES = /* @__PURE__ */ new Set(["startup", "resume"]);
 var CONNECTED_SENTENCE = `Halfcycle's sign-in works and its service answered. If its tools are missing, turn on ${MCP_SERVER_KEY} in /mcp; if it is not listed, run "claude mcp reset-project-choices" here and restart Claude Code.`;
 var INITIALIZE_BODY = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: {} });
+var SESSION_START_PROBE_ATTEMPTS = 2;
 function registeredMcpUrl(projectRoot) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync22(resolve5(projectRoot, MCP_REGISTRATION_REL), "utf-8"));
+    parsed = JSON.parse(readFileSync26(resolve7(projectRoot, MCP_REGISTRATION_REL), "utf-8"));
   } catch {
     return void 0;
   }
@@ -29581,11 +31503,11 @@ async function postInitialize(url2, bearer, fetchFn, signal) {
   }
   return namesItsServer(body) ? void 0 : SERVICE_PROBLEM_SENTENCE;
 }
-async function probeDelivery(url2, bearer, fetchFn, deadlineMs) {
+async function probeDelivery(url2, bearer, fetchFn, deadlineMs, maxAttempts) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), deadlineMs);
   try {
-    for (let attempt2 = 0; attempt2 < 2; attempt2++) {
+    for (let attempt2 = 0; attempt2 < maxAttempts; attempt2++) {
       const outcome = await postInitialize(url2, bearer, fetchFn, controller.signal);
       if (outcome !== CUT_OFF)
         return outcome;
@@ -29611,7 +31533,7 @@ async function checkConnection(renewedToken, opts) {
   if (CREDENTIAL_PLACEHOLDERS.includes(bearer)) {
     return { sentence: PLACEHOLDER_SENTENCES[bearer], url: url2, bearer };
   }
-  const outcome = await probeDelivery(url2, bearer, opts.fetchFn ?? globalThis.fetch, opts.checkDeadlineMs ?? CONNECTION_CHECK_DEADLINE_MS);
+  const outcome = await probeDelivery(url2, bearer, opts.fetchFn ?? globalThis.fetch, opts.checkDeadlineMs ?? CONNECTION_CHECK_DEADLINE_MS, opts.maxAttempts ?? SESSION_START_PROBE_ATTEMPTS);
   return { sentence: outcome ?? CONNECTED_SENTENCE, url: url2, bearer };
 }
 function positionRequestBody(engagementId) {
@@ -29722,6 +31644,20 @@ async function runRefreshCredential(opts) {
         }
       }
     }
+    if (CHECKED_SOURCES.has(input["source"])) {
+      const config2 = readConfig().config;
+      if (config2 !== null) {
+        const remainingForMargin = SESSION_START_HOOK_TIMEOUT_MS - SESSION_START_MARGIN_MS - (Date.now() - startedAt);
+        await cacheAutonomySetting({
+          controlOrigin: readControlOrigin().origin,
+          engagementId: config2.guardEngagementId,
+          bearer: renewedToken ?? config2.guardServiceToken,
+          fetchFn: opts.fetchFn ?? globalThis.fetch,
+          home: opts.home,
+          deadlineMs: Math.min(opts.autonomyStateDeadlineMs ?? AUTONOMY_STATE_DEADLINE_MS, remainingForMargin)
+        });
+      }
+    }
     if (readConfig().config === null) {
       const remedySaid = parts.some(namesTheSignInCommand);
       parts.push(noCoverageStatement(readNeverConfiguredReason(), remedySaid, pinnedEngagementId(projectRootFromBinary(opts.binaryPath))));
@@ -29748,8 +31684,8 @@ async function runRefreshCredential(opts) {
 import { fileURLToPath } from "node:url";
 
 // dist/capture.js
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync12, mkdirSync as mkdirSync8, existsSync as existsSync8 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync15, mkdirSync as mkdirSync10, existsSync as existsSync9 } from "node:fs";
+import { dirname as dirname10 } from "node:path";
 function runCapture(provider, endpoint, opts = {}) {
   const repoRoot = opts.repoRoot ?? process.cwd();
   const raw = opts.input ?? readInputFile(opts.fromFile);
@@ -29784,8 +31720,8 @@ function runCapture(provider, endpoint, opts = {}) {
   const fixture = fixturePath(repoRoot, provider, slug);
   const manifestFile = manifestPath(repoRoot);
   try {
-    mkdirSync8(dirname7(fixture), { recursive: true });
-    writeFileSync12(fixture, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+    mkdirSync10(dirname10(fixture), { recursive: true });
+    writeFileSync15(fixture, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { ok: false, kind: "write-failed", message: `could not write fixture: ${msg}` };
@@ -29816,7 +31752,7 @@ function readInputFile(fromFile) {
   if (!fromFile)
     return void 0;
   try {
-    return readFileSync23(fromFile, "utf-8");
+    return readFileSync27(fromFile, "utf-8");
   } catch {
     return void 0;
   }
@@ -29827,11 +31763,11 @@ function relativeFixturePath(repoRoot, fixture) {
 }
 
 // dist/prove.js
-import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
-import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
-import { createWriteStream, mkdirSync as mkdirSync9, readdirSync as readdirSync9, readFileSync as readFileSync24, renameSync as renameSync10, unlinkSync as unlinkSync9, writeFileSync as writeFileSync13 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { dirname as dirname8, join as join15 } from "node:path";
+import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
+import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
+import { createWriteStream, mkdirSync as mkdirSync11, readdirSync as readdirSync10, readFileSync as readFileSync28, renameSync as renameSync13, unlinkSync as unlinkSync11, writeFileSync as writeFileSync16 } from "node:fs";
+import { homedir as homedir14 } from "node:os";
+import { dirname as dirname11, join as join19 } from "node:path";
 
 // dist/test-counts.js
 function sum(values) {
@@ -29866,36 +31802,36 @@ function jestCounts(output) {
   if (lines2.length === 0)
     return null;
   let passed = 0;
-  let failed = 0;
+  let failed2 = 0;
   for (const line2 of lines2) {
     passed += firstNumber(line2[1], /(\d+) passed/) ?? 0;
-    failed += firstNumber(line2[1], /(\d+) failed/) ?? 0;
+    failed2 += firstNumber(line2[1], /(\d+) failed/) ?? 0;
   }
-  return { passed, failed };
+  return { passed, failed: failed2 };
 }
 function vitestCounts(output) {
   const lines2 = [...output.matchAll(/^\s*Tests\s+(.+)$/gm)];
   if (lines2.length === 0)
     return null;
   let passed = 0;
-  let failed = 0;
+  let failed2 = 0;
   for (const line2 of lines2) {
     passed += firstNumber(line2[1], /(\d+) passed/) ?? 0;
-    failed += firstNumber(line2[1], /(\d+) failed/) ?? 0;
+    failed2 += firstNumber(line2[1], /(\d+) failed/) ?? 0;
   }
-  return { passed, failed };
+  return { passed, failed: failed2 };
 }
 function pytestCounts(output) {
   const lines2 = [...output.matchAll(/^\W*((?:\d+ \w+(?:, )?)+)\s+in [\d.]+s\W*$/gm)];
   if (lines2.length === 0)
     return null;
   let passed = 0;
-  let failed = 0;
+  let failed2 = 0;
   for (const line2 of lines2) {
     passed += firstNumber(line2[1], /(\d+) passed/) ?? 0;
-    failed += firstNumber(line2[1], /(\d+) failed/) ?? 0;
+    failed2 += firstNumber(line2[1], /(\d+) failed/) ?? 0;
   }
-  return { passed, failed };
+  return { passed, failed: failed2 };
 }
 function cargoTestCounts(output) {
   const lines2 = [...output.matchAll(/^test result: (?:ok|FAILED)\.\s*(\d+) passed;\s*(\d+) failed;/gm)];
@@ -29940,19 +31876,19 @@ function isProofTestPath(path) {
 function testRunsDir(engagementId, home) {
   if (!isEngagementId(engagementId))
     return null;
-  return join15(home ?? homedir12(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, TEST_RUNS_DIR_NAME);
+  return join19(home ?? homedir14(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, TEST_RUNS_DIR_NAME);
 }
 function commandIdOf(command) {
-  return createHash4("sha256").update(command, "utf8").digest("hex").slice(0, 16);
+  return createHash5("sha256").update(command, "utf8").digest("hex").slice(0, 16);
 }
 var PLAIN_WORD = /^[A-Za-z0-9_./:=@%+,-]+$/;
-function commandFromWords(words, platform3 = process.platform) {
+function commandFromWords(words, platform4 = process.platform) {
   if (words.length === 1)
     return words[0];
   return words.map((word) => {
     if (PLAIN_WORD.test(word))
       return word;
-    return platform3 === "win32" ? `"${word.replace(/"/g, '""')}"` : quoteForShell(word);
+    return platform4 === "win32" ? `"${word.replace(/"/g, '""')}"` : quoteForShell(word);
   }).join(" ");
 }
 var PROVE_USAGE = 'Usage: prove <phase> <task> --label "<label>" --before -- <test command>\n       prove <phase> <task> --label "<label>" --after [-- <test command>]\n       (or --change <id> in place of <phase> <task>; add --reason "<why>" to say why)';
@@ -30026,21 +31962,21 @@ function parseProveArgs(args2) {
   };
 }
 function writeJsonFile2(path, value) {
-  mkdirSync9(dirname8(path), { recursive: true, mode: 448 });
-  const tmp = `${path}.${process.pid}.${randomUUID2()}.tmp`;
-  writeFileSync13(tmp, JSON.stringify(value), { mode: 384 });
-  renameSync10(tmp, path);
+  mkdirSync11(dirname11(path), { recursive: true, mode: 448 });
+  const tmp = `${path}.${process.pid}.${randomUUID3()}.tmp`;
+  writeFileSync16(tmp, JSON.stringify(value), { mode: 384 });
+  renameSync13(tmp, path);
 }
 function subjectKey(subject) {
   return subject.kind === "task" ? ["task", subject.phase, subject.task] : ["change", subject.change];
 }
 function keptCheckPath(dir, subject, label) {
-  const key = createHash4("sha256").update(JSON.stringify([...subjectKey(subject), label]), "utf8").digest("hex");
-  return join15(dir, COMMANDS_DIR_NAME, `${key.slice(0, 32)}.json`);
+  const key = createHash5("sha256").update(JSON.stringify([...subjectKey(subject), label]), "utf8").digest("hex");
+  return join19(dir, COMMANDS_DIR_NAME, `${key.slice(0, 32)}.json`);
 }
 function readKeptCheck(dir, subject, label) {
   try {
-    const raw = JSON.parse(readFileSync24(keptCheckPath(dir, subject, label), "utf-8"));
+    const raw = JSON.parse(readFileSync28(keptCheckPath(dir, subject, label), "utf-8"));
     if (typeof raw.command !== "string" || raw.command === "" || typeof raw.commandId !== "string")
       return null;
     const b = raw.before;
@@ -30051,21 +31987,21 @@ function readKeptCheck(dir, subject, label) {
   }
 }
 function queuePath(dir, runId) {
-  return join15(dir, QUEUE_DIR_NAME, `${runId}.json`);
+  return join19(dir, QUEUE_DIR_NAME, `${runId}.json`);
 }
 function readQueue(dir) {
   let names;
   try {
-    names = readdirSync9(join15(dir, QUEUE_DIR_NAME)).filter((n) => n.endsWith(".json"));
+    names = readdirSync10(join19(dir, QUEUE_DIR_NAME)).filter((n) => n.endsWith(".json"));
   } catch {
     return [];
   }
   const reports = [];
   for (const name of names) {
-    const path = join15(dir, QUEUE_DIR_NAME, name);
+    const path = join19(dir, QUEUE_DIR_NAME, name);
     let parsed = null;
     try {
-      parsed = testRunReportSchema.safeParse(JSON.parse(readFileSync24(path, "utf-8")));
+      parsed = testRunReportSchema.safeParse(JSON.parse(readFileSync28(path, "utf-8")));
     } catch {
       parsed = null;
     }
@@ -30078,7 +32014,7 @@ function readQueue(dir) {
 }
 function removeFile(path) {
   try {
-    unlinkSync9(path);
+    unlinkSync11(path);
   } catch {
   }
 }
@@ -30118,13 +32054,13 @@ async function sendQueuedRuns(dir, config2, controlOrigin, fetchFn) {
   }
   return outcomes;
 }
-function killTree(child, platform3, signal) {
+function killTree(child, platform4, signal) {
   const pid = child.pid;
   if (pid === void 0)
     return;
   try {
-    if (platform3 === "win32") {
-      spawnSync2("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true });
+    if (platform4 === "win32") {
+      spawnSync3("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true });
     } else {
       process.kill(-pid, signal);
     }
@@ -30136,16 +32072,16 @@ function killTree(child, platform3, signal) {
   }
 }
 function runCommand(command, repoRoot, logPath, env, deps) {
-  const platform3 = deps.platform ?? process.platform;
+  const platform4 = deps.platform ?? process.platform;
   const out = deps.stdout ?? process.stdout;
   const err = deps.stderr ?? process.stderr;
   const deadline = deps.deadlineMs ?? PROVE_RUN_DEADLINE_MS;
   const childEnv = { ...env };
   delete childEnv[SERVICE_TOKEN_VAR];
-  mkdirSync9(dirname8(logPath), { recursive: true, mode: 448 });
+  mkdirSync11(dirname11(logPath), { recursive: true, mode: 448 });
   const log = createWriteStream(logPath, { mode: 384 });
   const began = process.hrtime.bigint();
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     let timedOut = false;
     let started = true;
     let settled = false;
@@ -30154,15 +32090,15 @@ function runCommand(command, repoRoot, logPath, env, deps) {
       env: childEnv,
       shell: true,
       stdio: ["ignore", "pipe", "pipe"],
-      detached: platform3 !== "win32",
+      detached: platform4 !== "win32",
       windowsHide: true
     });
-    const onSignal = (signal) => killTree(child, platform3, signal);
+    const onSignal = (signal) => killTree(child, platform4, signal);
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
     const timer = setTimeout(() => {
       timedOut = true;
-      killTree(child, platform3, "SIGKILL");
+      killTree(child, platform4, "SIGKILL");
     }, deadline);
     child.stdout?.on("data", (chunk) => {
       out.write(chunk);
@@ -30180,7 +32116,7 @@ function runCommand(command, repoRoot, logPath, env, deps) {
       process.off("SIGINT", onSignal);
       process.off("SIGTERM", onSignal);
       const durationMs = Number((process.hrtime.bigint() - began) / 1000000n);
-      log.end(() => resolve6({ exitCode: timedOut || !started ? null : code, timedOut, started, durationMs }));
+      log.end(() => resolve8({ exitCode: timedOut || !started ? null : code, timedOut, started, durationMs }));
     };
     child.on("error", (e) => {
       started = false;
@@ -30301,14 +32237,14 @@ ${PROVE_USAGE}`);
   }
   if (request.when === "before" && changedOutsideTests > 0)
     say(lateBeforeLine(changedOutsideTests));
-  const runId = randomUUID2();
-  const logPath = join15(dir, `${runId}.log`);
+  const runId = randomUUID3();
+  const logPath = join19(dir, `${runId}.log`);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const deadline = deps.deadlineMs ?? PROVE_RUN_DEADLINE_MS;
   const end = await runCommand(command, repoRoot, logPath, env, deps);
   let output = "";
   try {
-    output = readFileSync24(logPath, "utf-8");
+    output = readFileSync28(logPath, "utf-8");
   } catch {
     output = "";
   }
@@ -30358,7 +32294,7 @@ ${PROVE_USAGE}`);
 
 // dist/statusline.js
 import { spawn as spawn3 } from "node:child_process";
-import { readFileSync as readFileSync25 } from "node:fs";
+import { readFileSync as readFileSync29 } from "node:fs";
 import nodePath5 from "node:path";
 var OWN_STATUS_LINE_DEADLINE_MS = 5e3;
 var PERSON_SETTINGS_FILENAME = "settings.json";
@@ -30396,7 +32332,7 @@ function halfcycleStatusLineOf(figures) {
 }
 function personStatusLineCommand(configFolder) {
   try {
-    const v = JSON.parse(readFileSync25(nodePath5.join(configFolder, PERSON_SETTINGS_FILENAME), "utf-8"));
+    const v = JSON.parse(readFileSync29(nodePath5.join(configFolder, PERSON_SETTINGS_FILENAME), "utf-8"));
     const line2 = v["statusLine"];
     if (typeof line2 !== "object" || line2 === null)
       return null;
@@ -30420,14 +32356,14 @@ function personCommandEnv(env) {
   }
   return out;
 }
-var runOwnCommandReal = (command, input, env) => new Promise((resolve6) => {
+var runOwnCommandReal = (command, input, env) => new Promise((resolve8) => {
   let out = "";
   let settled = false;
   const done = (v) => {
     if (settled)
       return;
     settled = true;
-    resolve6(v);
+    resolve8(v);
   };
   try {
     const child = spawn3(command, {
@@ -30490,6 +32426,43 @@ async function runStatusline(raw, deps = {}) {
 `;
 }
 
+// dist/check-connection.js
+function connectionKind(bearer, sentence) {
+  if (bearer === NOT_THIS_ACCOUNT_PLACEHOLDER)
+    return "other-account";
+  if (bearer === UPDATE_CLAUDE_CODE_PLACEHOLDER)
+    return "update-claude-code";
+  if (bearer === NO_CREDENTIAL_PLACEHOLDER)
+    return "not-signed-in";
+  if (sentence === CONNECTED_SENTENCE)
+    return "connected";
+  if (sentence === CANNOT_REACH_SENTENCE)
+    return "cannot-reach";
+  if (sentence === SERVICE_PROBLEM_SENTENCE)
+    return "service-problem";
+  if (sentence === NO_CREDENTIAL_SENTENCE)
+    return "signed-out";
+  throw new Error("the connection check gave an outcome with no kind");
+}
+async function checkConnectionLine(opts) {
+  const result = await checkConnection(void 0, {
+    ...opts,
+    maxAttempts: 1,
+    writeErr: opts.writeErr ?? discardReason
+  });
+  if (result === void 0)
+    return { kind: "not-registered", sentence: null };
+  return { kind: connectionKind(result.bearer, result.sentence), sentence: result.sentence };
+}
+async function runCheckConnection(opts) {
+  const line2 = await checkConnectionLine(opts);
+  return `${JSON.stringify(line2)}
+`;
+}
+function discardReason() {
+  return void 0;
+}
+
 // dist/bin.js
 var args = process.argv.slice(2);
 async function main() {
@@ -30572,6 +32545,18 @@ async function main() {
     process.stdout.write(line2, () => process.exit(0));
     return;
   }
+  if (cmd === "check-connection") {
+    let line2;
+    try {
+      line2 = await runCheckConnection({ binaryPath: fileURLToPath(import.meta.url) });
+    } catch {
+      process.stderr.write("halfcycle-runner: the connection could not be checked.\n");
+      process.exit(1);
+      return;
+    }
+    process.stdout.write(line2, () => process.exit(0));
+    return;
+  }
   if (cmd === "mcp-headers") {
     const line2 = await mcpHeaders({ binaryPath: fileURLToPath(import.meta.url) });
     process.stdout.write(line2, () => process.exit(0));
@@ -30650,8 +32635,18 @@ Commit the fixture; the next guard evaluation of this endpoint will pass.
       process.stdout.write(reply, () => process.exit(0));
       return;
     }
+    if (sub === "user-prompt-findings") {
+      let reply = "";
+      try {
+        reply = runUserPromptFindings({ input: await readStdin2() });
+      } catch {
+        reply = "";
+      }
+      process.stdout.write(reply, () => process.exit(0));
+      return;
+    }
     process.stderr.write(`halfcycle-runner: unknown hook "${sub ?? ""}"
-  Valid hooks: post-tool-use, pre-tool-use, stop, subagent-stop, user-prompt-submit
+  Valid hooks: post-tool-use, pre-tool-use, stop, subagent-stop, user-prompt-submit, user-prompt-findings
 `);
     process.exit(1);
     return;
@@ -30663,7 +32658,9 @@ Commit the fixture; the next guard evaluation of this endpoint will pass.
          halfcycle-runner hook stop
          halfcycle-runner hook subagent-stop
          halfcycle-runner hook user-prompt-submit
+         halfcycle-runner hook user-prompt-findings
          halfcycle-runner refresh-credential
+         halfcycle-runner check-connection
          halfcycle-runner mcp-headers
          halfcycle-runner observe
          halfcycle-runner observe --change <sortingId>
@@ -30678,10 +32675,10 @@ Commit the fixture; the next guard evaluation of this endpoint will pass.
   process.exit(1);
 }
 function readStdin3() {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve6(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("end", () => resolve8(Buffer.concat(chunks).toString("utf-8")));
     process.stdin.on("error", reject);
   });
 }