@linghun/tui 0.1.0

package/dist/chunk-7ZE5JFAZ.js

@@ -0,0 +1,760 @@
+import {
+  GIT_ROLLBACK_EXPLAIN,
+  GIT_STABLE_POINT_CREATE,
+  GIT_STATUS_INSPECT,
+  MANAGED_WORKTREE_CREATE,
+  parseStablePointInput,
+  parseWorktreeCreateInput,
+  parseWorktreeRemoveInput,
+  summarizeStablePointOutcome,
+  summarizeWorktreeContextForPrompt,
+  summarizeWorktreeCreateOutcome,
+  summarizeWorktreeRemovePlan
+} from "./chunk-6USL33ZO.js";
+import {
+  computeWorktreeContext,
+  createGitStablePoint,
+  createManagedWorktree,
+  defaultStablePointMessage,
+  executeManagedWorktreeRemove,
+  planManagedWorktreeRemove,
+  validateStablePointMessage
+} from "./chunk-4EIC5BCT.js";
+import {
+  readGitStatus,
+  readWorktreeList
+} from "./chunk-AO4CXI37.js";
+
+// src/git-tool-dispatch-runtime.ts
+function extractGitToolTarget(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const obj = input;
+  if (typeof obj.branch === "string") return obj.branch;
+  if (typeof obj.message === "string") {
+    const msg = obj.message.trim();
+    return msg.length > 30 ? `${msg.slice(0, 27)}\u2026` : msg;
+  }
+  if (typeof obj.ref === "string") return obj.ref;
+  return void 0;
+}
+async function recordGitOperationEvidence(deps, context, sessionId, operation, summary, extraClaims) {
+  const evidence = deps.createEvidenceRecord(
+    "command_output",
+    `git_operation ${operation}: ${summary}`,
+    `git-operation:${operation}`,
+    ["git_operation", operation, ...extraClaims]
+  );
+  await context.store.appendEvent(sessionId, {
+    type: "evidence_record",
+    ...evidence
+  });
+  deps.rememberEvidence(context, evidence);
+  return evidence;
+}
+async function appendGitOperationEvent(deps, context, sessionId, fields, level) {
+  const safe = Object.entries(fields).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${typeof value === "string" ? value : JSON.stringify(value)}`).join("; ");
+  await deps.appendSystemEvent(context, sessionId, safe, level);
+}
+async function createSnapshotStablePoint(deps, context, sessionId, reason) {
+  const status = await readGitStatus(context.projectPath);
+  const changedFiles = status.kind === "ok" ? [...status.staged, ...status.unstaged, ...status.untracked].slice(0, 50) : [];
+  const checkpoint = {
+    id: deps.randomUUID(),
+    sessionId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    reason,
+    changedFiles,
+    restoreKind: "snapshot",
+    files: []
+  };
+  for (const file of changedFiles) {
+    const target = deps.resolvePath(context.projectPath, file);
+    try {
+      checkpoint.files.push({
+        path: file,
+        existed: true,
+        content: await deps.readFileUtf8(target)
+      });
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        checkpoint.files.push({ path: file, existed: false });
+        continue;
+      }
+      checkpoint.files.push({ path: file, existed: false });
+    }
+  }
+  context.checkpoints.unshift(checkpoint);
+  context.checkpoints = context.checkpoints.slice(0, deps.maxCheckpoints);
+  await context.store.appendEvent(sessionId, {
+    type: "checkpoint_created",
+    checkpoint: {
+      id: checkpoint.id,
+      sessionId: checkpoint.sessionId,
+      createdAt: checkpoint.createdAt,
+      reason: checkpoint.reason,
+      changedFiles: checkpoint.changedFiles,
+      restoreKind: checkpoint.restoreKind,
+      restorable: false,
+      restoreUnavailableReason: "git stable checkpoint payload is kept in-memory only to avoid persisting broad dirty-file contents"
+    },
+    createdAt: checkpoint.createdAt
+  });
+  return checkpoint;
+}
+async function executeGitToolUse(toolCall, context, sessionId, output, deps, continuation) {
+  deps.startRequestActivity(output, context, "tool_running", { toolName: toolCall.name, toolTarget: extractGitToolTarget(toolCall.input) });
+  await context.store.appendEvent(sessionId, {
+    type: "tool_call_start",
+    id: toolCall.id,
+    name: toolCall.name,
+    input: toolCall.input,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  try {
+    if (toolCall.name === GIT_STATUS_INSPECT) {
+      return await runGitStatusInspectTool(toolCall, context, sessionId, output, deps);
+    }
+    if (toolCall.name === GIT_ROLLBACK_EXPLAIN) {
+      return await runGitRollbackExplainTool(toolCall, context, sessionId, output, deps);
+    }
+    if (toolCall.name === GIT_STABLE_POINT_CREATE) {
+      return await runStablePointTool(
+        toolCall,
+        context,
+        sessionId,
+        output,
+        deps,
+        parseStablePointInput(toolCall.input),
+        continuation
+      );
+    }
+    if (toolCall.name === MANAGED_WORKTREE_CREATE) {
+      return await runWorktreeCreateTool(toolCall, context, sessionId, output, deps);
+    }
+    return await runWorktreeRemoveTool(toolCall, context, sessionId, output, deps, continuation);
+  } catch (error) {
+    deps.clearRequestActivity(context);
+    const text = deps.formatError(error, context.language);
+    const evidence = await deps.recordToolFailureEvidence(
+      context,
+      sessionId,
+      "Read",
+      `${toolCall.name}: ${text}`
+    );
+    await deps.appendDeferredToolResultEvent(
+      context,
+      sessionId,
+      toolCall.id,
+      toolCall.name,
+      text,
+      true,
+      evidence.id
+    );
+    return { ok: false, tool: toolCall.name, text, evidenceId: evidence.id };
+  }
+}
+async function runGitRollbackExplainTool(toolCall, context, sessionId, output, deps) {
+  const isEn = context.language === "en-US";
+  const text = isEn ? "Git rollback boundary: Linghun can restore in-memory snapshot checkpoints with /rewind restore, but this tool does not execute git revert/reset/checkout and does not move HEAD. For a real git rollback, inspect /git status first, then run an explicit shell/git command after choosing revert vs reset." : "Git \u56DE\u6EDA\u8FB9\u754C\uFF1ALinghun \u53EF\u7528 /rewind restore \u6062\u590D\u5185\u5B58 snapshot checkpoint\uFF0C\u4F46\u6B64\u5DE5\u5177\u4E0D\u4F1A\u6267\u884C git revert/reset/checkout\uFF0C\u4E5F\u4E0D\u4F1A\u79FB\u52A8 HEAD\u3002\u771F\u5B9E git \u56DE\u6EDA\u8BF7\u5148\u67E5\u770B /git status\uFF0C\u518D\u7531\u7528\u6237\u660E\u786E\u9009\u62E9 revert \u6216 reset \u540E\u624B\u52A8\u6267\u884C\u5BF9\u5E94 git \u547D\u4EE4\u3002";
+  const data = {
+    mutating: false,
+    movesHead: false,
+    executesGitRollback: false,
+    snapshotRestoreCommand: "/rewind restore <checkpointId>",
+    gitStatusCommand: "/git status"
+  };
+  const evidence = await deps.recordToolEvidence(context, sessionId, "Read", {
+    text: `GitRollbackExplain: ${text}`,
+    data
+  }, {
+    query: "GitRollbackExplain"
+  });
+  await deps.appendDeferredToolResultEvent(
+    context,
+    sessionId,
+    toolCall.id,
+    toolCall.name,
+    { text, data },
+    false,
+    evidence?.id
+  );
+  deps.clearRequestActivity(context);
+  deps.writeLine(output, text);
+  return { ok: true, tool: toolCall.name, text, data, evidenceId: evidence?.id };
+}
+async function runGitStatusInspectTool(toolCall, context, sessionId, output, deps) {
+  const status = await readGitStatus(context.projectPath);
+  const worktrees = await readWorktreeList(context.projectPath);
+  const worktreeContext = await computeWorktreeContext(context.projectPath);
+  const summary = status.kind === "ok" ? `branch ${status.branch ?? "(detached)"}; changed ${status.changedCount}; untracked ${status.untrackedCount}; head ${status.headShort ?? "?"}` : status.kind === "not_a_git_repo" ? "not a git repository" : `git unavailable: ${status.error}`;
+  const data = {
+    status: status.kind === "ok" ? {
+      branch: status.branch,
+      head: status.headShort,
+      changedCount: status.changedCount,
+      untrackedCount: status.untrackedCount,
+      ahead: status.ahead,
+      behind: status.behind
+    } : { kind: status.kind },
+    worktree: summarizeWorktreeContextForPrompt(worktreeContext),
+    worktreeCount: worktrees.kind === "ok" ? worktrees.entries.length : 0
+  };
+  const evidence = await deps.recordToolEvidence(context, sessionId, "Read", {
+    text: `GitStatusInspect: ${summary}`,
+    data
+  });
+  await deps.appendDeferredToolResultEvent(
+    context,
+    sessionId,
+    toolCall.id,
+    toolCall.name,
+    { text: summary, data },
+    false,
+    evidence?.id
+  );
+  deps.clearRequestActivity(context);
+  deps.writeLine(
+    output,
+    context.language === "en-US" ? `Git status: ${summary}` : `Git \u72B6\u6001\uFF1A${summary}`
+  );
+  return { ok: true, tool: toolCall.name, text: summary, data, evidenceId: evidence?.id };
+}
+async function runStablePointTool(toolCall, context, sessionId, output, deps, input, continuation) {
+  if (context.permissionMode === "plan") {
+    deps.clearRequestActivity(context);
+    const text = context.language === "en-US" ? "stable point was NOT created because Plan mode is read-only." : "stable point was NOT created because Plan mode is read-only. \u7A33\u5B9A\u70B9\u672A\u521B\u5EFA\uFF1A\u8BA1\u5212\u6A21\u5F0F\u53EA\u8BFB\u3002";
+    const evidence = await deps.recordToolFailureEvidence(
+      context,
+      sessionId,
+      "Read",
+      `GitStablePointCreate denied: ${text}`
+    );
+    await appendGitOperationEvent(
+      deps,
+      context,
+      sessionId,
+      {
+        operation: "stable_point_denied",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        project: context.projectPath,
+        includeUntracked: Boolean(input.includeUntracked),
+        result: "plan_read_only"
+      },
+      "warning"
+    );
+    await deps.appendDeferredToolResultEvent(
+      context,
+      sessionId,
+      toolCall.id,
+      toolCall.name,
+      { text, ok: false, outcome: "plan_read_only" },
+      true,
+      evidence.id
+    );
+    deps.writeLine(output, text);
+    return { ok: false, tool: toolCall.name, text, evidenceId: evidence.id };
+  }
+  if (context.permissionMode === "default") {
+    deps.clearRequestActivity(context);
+    context.pendingLocalApproval = {
+      kind: "git_stable_point",
+      sessionId,
+      message: input.message,
+      includeUntracked: input.includeUntracked,
+      continuation: continuation ? deps.createSingleToolCallContinuation(continuation, toolCall) : void 0,
+      toolCall
+    };
+    const summaryText = context.language === "en-US" ? "Confirm creating a stable point (git commit / snapshot) for the current workspace." : "\u786E\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u533A\u521B\u5EFA\u7A33\u5B9A\u70B9\uFF08git commit / snapshot\uFF09\u3002";
+    await appendGitOperationEvent(
+      deps,
+      context,
+      sessionId,
+      {
+        operation: "stable_point_requested",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        project: context.projectPath,
+        includeUntracked: Boolean(input.includeUntracked),
+        result: "pending_confirmation"
+      },
+      "info"
+    );
+    if (!context.isInkSession) {
+      deps.writeLine(output, summaryText);
+    }
+    return { ok: false, tool: toolCall.name, text: summaryText, pendingApproval: true };
+  }
+  const result = await performStablePoint(context, sessionId, input, deps);
+  deps.clearRequestActivity(context);
+  await deps.appendDeferredToolResultEvent(
+    context,
+    sessionId,
+    toolCall.id,
+    toolCall.name,
+    { text: result.text, ok: result.ok },
+    !result.ok,
+    result.evidenceId
+  );
+  deps.writeLine(output, result.text);
+  return { ok: result.ok, tool: toolCall.name, text: result.text, evidenceId: result.evidenceId };
+}
+async function performStablePoint(context, sessionId, input, deps) {
+  let message = input.message?.trim() ?? "";
+  if (message === "") {
+    message = defaultStablePointMessage();
+  } else {
+    const check = validateStablePointMessage(message);
+    if (!check.ok) {
+      return { ok: false, text: `\u7A33\u5B9A\u70B9 message \u975E\u6CD5\uFF1A${check.reason}`, outcome: "snapshot_only" };
+    }
+    message = check.message;
+  }
+  await createSnapshotStablePoint(deps, context, sessionId, `before stable point: ${message}`);
+  const outcome = await createGitStablePoint(context.projectPath, {
+    message,
+    includeUntracked: input.includeUntracked
+  });
+  const { ok, text } = summarizeStablePointOutcome(outcome, context.language);
+  if (outcome.kind === "git_commit") {
+    const evidence = await recordGitOperationEvidence(
+      deps,
+      context,
+      sessionId,
+      "stable_point_created",
+      `kind git commit; sha ${outcome.sha}; branch ${outcome.branch ?? "-"}; changed ${outcome.changedCount}`,
+      ["stable_point_created"]
+    );
+    await appendGitOperationEvent(
+      deps,
+      context,
+      sessionId,
+      {
+        operation: "stable_point_created",
+        kind: "git_commit",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        project: context.projectPath,
+        branch: outcome.branch,
+        sha: outcome.sha,
+        subject: outcome.subject,
+        changedCount: outcome.changedCount,
+        includedUntracked: outcome.includedUntracked,
+        rejectedUntracked: outcome.rejectedUntracked.length,
+        result: "ok"
+      },
+      "info"
+    );
+    return { ok, text, evidenceId: evidence.id, outcome };
+  }
+  if (outcome.kind === "skipped") {
+    await appendGitOperationEvent(
+      deps,
+      context,
+      sessionId,
+      {
+        operation: "stable_point_skipped",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        branch: outcome.branch,
+        head: outcome.head,
+        result: "skipped"
+      },
+      "info"
+    );
+    return { ok, text, outcome };
+  }
+  if (outcome.kind === "snapshot" || outcome.kind === "not_a_git_repo") {
+    const reason = outcome.kind === "not_a_git_repo" ? "not_a_git_repo" : outcome.reason;
+    const evidence = await recordGitOperationEvidence(
+      deps,
+      context,
+      sessionId,
+      "stable_point_created",
+      `kind snapshot; reason ${reason}`,
+      ["stable_point_created"]
+    );
+    await appendGitOperationEvent(
+      deps,
+      context,
+      sessionId,
+      {
+        operation: "stable_point_created",
+        kind: "snapshot",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        reason,
+        result: "ok"
+      },
+      "info"
+    );
+    return { ok, text, evidenceId: evidence.id, outcome };
+  }
+  await appendGitOperationEvent(
+    deps,
+    context,
+    sessionId,
+    {
+      operation: "git_operation_failed",
+      target: "stable_point",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: text,
+      result: "failed"
+    },
+    "warning"
+  );
+  return { ok, text, outcome };
+}
+async function runWorktreeCreateTool(toolCall, context, sessionId, output, deps) {
+  const input = parseWorktreeCreateInput(toolCall.input);
+  const result = await performWorktreeCreate(
+    context,
+    sessionId,
+    { name: input.name ?? "", branch: input.branch, fromRef: input.fromRef },
+    deps
+  );
+  deps.clearRequestActivity(context);
+  await deps.appendDeferredToolResultEvent(
+    context,
+    sessionId,
+    toolCall.id,
+    toolCall.name,
+    { text: result.text, ok: result.ok },
+    !result.ok,
+    result.evidenceId
+  );
+  deps.writeLine(output, result.text);
+  return { ok: result.ok, tool: toolCall.name, text: result.text, evidenceId: result.evidenceId };
+}
+async function performWorktreeCreate(context, sessionId, input, deps) {
+  const outcome = await createManagedWorktree(context.projectPath, input);
+  const { ok, text } = summarizeWorktreeCreateOutcome(outcome, context.language);
+  if (outcome.kind === "created") {
+    const evidence = await recordGitOperationEvidence(
+      deps,
+      context,
+      sessionId,
+      "worktree_created",
+      `name ${outcome.name}; branch ${outcome.branch ?? "-"}; from ${outcome.fromRef}`,
+      ["worktree_created"]
+    );
+    await appendGitOperationEvent(
+      deps,
+      context,
+      sessionId,
+      {
+        operation: "worktree_created",
+        createdAt: outcome.createdAt,
+        project: context.projectPath,
+        name: outcome.name,
+        path: outcome.path,
+        branch: outcome.branch,
+        fromRef: outcome.fromRef,
+        head: outcome.head,
+        managedRoot: outcome.managedRoot,
+        result: "ok"
+      },
+      "info"
+    );
+    return { ok, text, evidenceId: evidence.id, outcome };
+  }
+  if (outcome.kind === "resumed") {
+    const evidence = await recordGitOperationEvidence(
+      deps,
+      context,
+      sessionId,
+      "worktree_resumed",
+      `name ${outcome.name}; branch ${outcome.branch ?? "-"}`,
+      ["worktree_resumed"]
+    );
+    await appendGitOperationEvent(
+      deps,
+      context,
+      sessionId,
+      {
+        operation: "worktree_resumed",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        name: outcome.name,
+        path: outcome.path,
+        managedRoot: outcome.managedRoot,
+        result: "exists"
+      },
+      "info"
+    );
+    return { ok, text, evidenceId: evidence.id, outcome };
+  }
+  await appendGitOperationEvent(
+    deps,
+    context,
+    sessionId,
+    {
+      operation: "git_operation_failed",
+      target: "worktree_create",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: text,
+      result: "failed"
+    },
+    "warning"
+  );
+  return { ok, text, outcome };
+}
+async function runWorktreeRemoveTool(toolCall, context, sessionId, output, deps, continuation) {
+  const input = parseWorktreeRemoveInput(toolCall.input);
+  const plan = await planManagedWorktreeRemove(context.projectPath, {
+    name: input.name ?? "",
+    force: input.force
+  });
+  const summary = summarizeWorktreeRemovePlan(plan, context.language);
+  deps.clearRequestActivity(context);
+  if (summary.needsConfirmation && (plan.kind === "clean" || plan.kind === "dirty_force")) {
+    context.pendingLocalApproval = {
+      kind: "git_worktree_remove",
+      sessionId,
+      name: plan.name,
+      path: plan.path,
+      force: plan.kind === "dirty_force",
+      strong: summary.strong,
+      continuation: continuation ? deps.createSingleToolCallContinuation(continuation, toolCall) : void 0,
+      toolCall
+    };
+    await appendGitOperationEvent(
+      deps,
+      context,
+      sessionId,
+      {
+        operation: "worktree_remove_requested",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        name: plan.name,
+        path: plan.path,
+        force: plan.kind === "dirty_force",
+        result: "pending_confirmation"
+      },
+      "info"
+    );
+    deps.writeLine(output, summary.text);
+    return { ok: false, tool: toolCall.name, text: summary.text, pendingApproval: true };
+  }
+  if (plan.kind === "dirty_blocked" || plan.kind === "not_managed") {
+    await appendGitOperationEvent(
+      deps,
+      context,
+      sessionId,
+      {
+        operation: "worktree_remove_denied",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        name: input.name,
+        reason: summary.text,
+        result: "denied"
+      },
+      "warning"
+    );
+  }
+  const evidence = await deps.recordToolFailureEvidence(
+    context,
+    sessionId,
+    "Read",
+    `ManagedWorktreeRemove: ${summary.text}`
+  );
+  await deps.appendDeferredToolResultEvent(
+    context,
+    sessionId,
+    toolCall.id,
+    toolCall.name,
+    summary.text,
+    true,
+    evidence.id
+  );
+  deps.writeLine(output, summary.text);
+  return { ok: false, tool: toolCall.name, text: summary.text, evidenceId: evidence.id };
+}
+async function performWorktreeRemoveExecute(context, sessionId, name, path, force, deps) {
+  const result = await executeManagedWorktreeRemove(context.projectPath, path, force);
+  if (result.kind === "removed") {
+    const evidence = await recordGitOperationEvidence(
+      deps,
+      context,
+      sessionId,
+      "worktree_removed",
+      `name ${name}; force ${force}`,
+      ["worktree_removed"]
+    );
+    await appendGitOperationEvent(
+      deps,
+      context,
+      sessionId,
+      {
+        operation: "worktree_removed",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        name,
+        path,
+        force,
+        result: "ok"
+      },
+      "info"
+    );
+    const text2 = context.language === "en-US" ? `Worktree removed: "${name}".` : `\u5DF2\u5220\u9664 worktree\uFF1A\u300C${name}\u300D\u3002`;
+    return { ok: true, text: text2, evidenceId: evidence.id, result };
+  }
+  await appendGitOperationEvent(
+    deps,
+    context,
+    sessionId,
+    {
+      operation: "git_operation_failed",
+      target: "worktree_remove",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      name,
+      reason: result.reason,
+      result: "failed"
+    },
+    "warning"
+  );
+  const text = context.language === "en-US" ? `Worktree removal failed; nothing removed: ${result.reason}` : `worktree \u5220\u9664\u5931\u8D25\uFF0C\u672A\u5220\u9664\uFF1A${result.reason}`;
+  return { ok: false, text, result };
+}
+var MANAGED_WORKTREE_REMOVE_TOOL = "ManagedWorktreeRemove";
+async function resolveWorktreeRemoveApprove(approval, context, output, deps) {
+  const result = await performWorktreeRemoveExecute(
+    context,
+    approval.sessionId,
+    approval.name,
+    approval.path,
+    approval.force,
+    deps
+  );
+  deps.writeLine(output, result.text);
+  if (approval.continuation && approval.toolCall) {
+    approval.continuation.messages.push({
+      role: "tool",
+      tool_call_id: approval.toolCall.id,
+      content: JSON.stringify({
+        ok: result.ok,
+        tool: MANAGED_WORKTREE_REMOVE_TOOL,
+        text: result.text,
+        evidenceId: result.evidenceId
+      })
+    });
+    await deps.continueAfterToolResults(approval.continuation, context, output);
+  }
+  deps.writeLightHints(output, context);
+  deps.writeStatus(output, context);
+}
+async function resolveWorktreeRemoveDeny(approval, context, output, cancelled, deps) {
+  const outcomeText = cancelled ? "permission cancelled by user" : "permission denied by user";
+  const evidence = await deps.recordToolFailureEvidence(
+    context,
+    approval.sessionId,
+    "Read",
+    `${outcomeText}: ManagedWorktreeRemove ${approval.name}`
+  );
+  await appendGitOperationEvent(
+    deps,
+    context,
+    approval.sessionId,
+    {
+      operation: "worktree_remove_denied",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      name: approval.name,
+      path: approval.path,
+      result: cancelled ? "cancelled" : "denied"
+    },
+    "warning"
+  );
+  const deniedText = context.language === "en-US" ? `Worktree removal ${cancelled ? "cancelled" : "denied"}; "${approval.name}" was not removed.` : `\u5DF2${cancelled ? "\u53D6\u6D88" : "\u62D2\u7EDD"}\u5220\u9664 worktree\uFF1B\u300C${approval.name}\u300D\u672A\u88AB\u5220\u9664\u3002`;
+  deps.writeLine(output, deniedText);
+  if (approval.continuation && approval.toolCall) {
+    approval.continuation.messages.push({
+      role: "tool",
+      tool_call_id: approval.toolCall.id,
+      content: JSON.stringify({
+        ok: false,
+        tool: MANAGED_WORKTREE_REMOVE_TOOL,
+        text: deniedText,
+        outcome: cancelled ? "cancelled" : "denied",
+        evidenceId: evidence.id
+      })
+    });
+    await deps.continueAfterToolResults(approval.continuation, context, output);
+  }
+  deps.writeLightHints(output, context);
+  deps.writeStatus(output, context);
+}
+async function resolveStablePointApprove(approval, context, output, deps) {
+  const result = await performStablePoint(
+    context,
+    approval.sessionId,
+    { message: approval.message, includeUntracked: approval.includeUntracked },
+    deps
+  );
+  await deps.appendDeferredToolResultEvent(
+    context,
+    approval.sessionId,
+    approval.toolCall.id,
+    GIT_STABLE_POINT_CREATE,
+    { text: result.text, ok: result.ok },
+    !result.ok,
+    result.evidenceId
+  );
+  deps.writeLine(output, result.text);
+  if (approval.continuation) {
+    approval.continuation.messages.push({
+      role: "tool",
+      tool_call_id: approval.toolCall.id,
+      content: JSON.stringify({
+        ok: result.ok,
+        tool: GIT_STABLE_POINT_CREATE,
+        text: result.text,
+        evidenceId: result.evidenceId
+      })
+    });
+    await deps.continueAfterToolResults(approval.continuation, context, output);
+  }
+  deps.writeLightHints(output, context);
+  deps.writeStatus(output, context);
+}
+async function resolveStablePointDeny(approval, context, output, cancelled, deps) {
+  const outcomeText = cancelled ? "permission cancelled by user" : "permission denied by user";
+  const evidence = await deps.recordToolFailureEvidence(
+    context,
+    approval.sessionId,
+    "Read",
+    `${outcomeText}: GitStablePointCreate`
+  );
+  await appendGitOperationEvent(
+    deps,
+    context,
+    approval.sessionId,
+    {
+      operation: "stable_point_denied",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      project: context.projectPath,
+      result: cancelled ? "cancelled" : "denied"
+    },
+    "warning"
+  );
+  const deniedText = context.language === "en-US" ? `Stable point ${cancelled ? "cancelled" : "denied"}; no commit or snapshot was created. The stable point was NOT created.` : `\u5DF2${cancelled ? "\u53D6\u6D88" : "\u62D2\u7EDD"}\u521B\u5EFA\u7A33\u5B9A\u70B9\uFF1B\u672A\u521B\u5EFA\u4EFB\u4F55 commit \u6216 snapshot\u3002\u7A33\u5B9A\u70B9\u672A\u521B\u5EFA\u3002`;
+  deps.writeLine(output, deniedText);
+  if (approval.continuation) {
+    approval.continuation.messages.push({
+      role: "tool",
+      tool_call_id: approval.toolCall.id,
+      content: JSON.stringify({
+        ok: false,
+        tool: GIT_STABLE_POINT_CREATE,
+        text: deniedText,
+        outcome: cancelled ? "cancelled" : "denied",
+        evidenceId: evidence.id
+      })
+    });
+    await deps.continueAfterToolResults(approval.continuation, context, output);
+  }
+  deps.writeLightHints(output, context);
+  deps.writeStatus(output, context);
+}
+
+export {
+  appendGitOperationEvent,
+  executeGitToolUse,
+  performStablePoint,
+  performWorktreeCreate,
+  performWorktreeRemoveExecute,
+  resolveWorktreeRemoveApprove,
+  resolveWorktreeRemoveDeny,
+  resolveStablePointApprove,
+  resolveStablePointDeny
+};