@adhdev/daemon-core 0.9.54 → 0.9.56

package/dist/boot/daemon-lifecycle.d.ts

@@ -52,6 +52,11 @@ export interface DaemonInitConfig {
     statusInstanceId?: string;
     statusVersion?: string;
     statusDaemonMode?: boolean;
+    /** Fired before send_chat is dispatched — used for turn snapshot hooks */
+    onBeforeSendChat?: (params: {
+        workspace: string;
+        sessionId: string;
+    }) => void;
 }
 export interface DaemonComponents {
     providerLoader: ProviderLoader;

package/dist/cli-adapters/provider-cli-adapter.d.ts

@@ -94,6 +94,12 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private accumulatedRawBuffer;
     /** Current visible terminal screen snapshot */
     private terminalScreen;
+    private static readonly MAX_RESPONSE_BUFFER;
+    private static readonly MAX_RECENT_OUTPUT_BUFFER;
+    private responseBufferDroppedChars;
+    private recentOutputDroppedChars;
+    private accumulatedBufferDroppedChars;
+    private accumulatedRawBufferDroppedChars;
     /** Max accumulated buffer size. Sized to comfortably hold a single long
      *  Hermes turn (tool calls + reasoning + final bubble) without the
      *  rolling window pushing the turn's ╭─ opening line out of view. */
@@ -111,6 +117,8 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private readonly providerResolutionMeta;
     private static readonly FINISH_RETRY_DELAY_MS;
     private static readonly MAX_FINISH_RETRIES;
+    private getBufferState;
+    private recordBoundedAppendDrop;
     private buildCommittedMessagesActivitySignature;
     private syncMessageViews;
     getLastCommittedMessageActivityAt(): number;
@@ -136,6 +144,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private readonly sendDelayMs;
     private readonly sendKey;
     private readonly submitStrategy;
+    private readonly requirePromptEchoBeforeSubmit;
     private static readonly SCRIPT_STATUS_DEBOUNCE_MS;
     constructor(provider: CliProviderModule, workingDir: string, extraArgs?: string[], transportFactory?: PtyTransportFactory);
     /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */

package/dist/cli-adapters/provider-cli-config.d.ts

@@ -27,6 +27,7 @@ export interface ResolvedCliAdapterConfig {
     sendDelayMs: number;
     sendKey: string;
     submitStrategy: 'wait_for_echo' | 'immediate';
+    requirePromptEchoBeforeSubmit: boolean;
     providerResolutionMeta: ProviderResolutionMeta;
 }
 export declare function resolveCliAdapterConfig(provider: CliProviderModule): ResolvedCliAdapterConfig;

package/dist/cli-adapters/provider-cli-shared.d.ts

@@ -22,6 +22,28 @@ export interface CliSessionStatus {
     } | null;
     errorMessage?: string;
     errorReason?: string;
+    bufferState?: {
+        responseBuffer?: {
+            truncated: boolean;
+            droppedChars: number;
+            maxChars: number;
+        };
+        recentOutputBuffer?: {
+            truncated: boolean;
+            droppedChars: number;
+            maxChars: number;
+        };
+        accumulatedBuffer?: {
+            truncated: boolean;
+            droppedChars: number;
+            maxChars: number;
+        };
+        accumulatedRawBuffer?: {
+            truncated: boolean;
+            droppedChars: number;
+            maxChars: number;
+        };
+    };
 }
 export interface ParsedSession {
     status: string;
@@ -123,6 +145,8 @@ export interface CliProviderModule {
     sendDelayMs?: number;
     sendKey?: string;
     submitStrategy?: 'wait_for_echo' | 'immediate';
+    /** Require the typed prompt to be visible on the PTY screen before sending Enter. */
+    requirePromptEchoBeforeSubmit?: boolean;
     /** Allow sending another prompt while the CLI is still generating so users can intervene mid-turn. */
     allowInputDuringGeneration?: boolean;
     /** When provider-owned, daemon treats provider parser output as canonical transcript authority. */

package/dist/commands/handler.d.ts

@@ -34,6 +34,11 @@ export interface CommandContext {
     onProviderSettingChanged?: (providerType: string, key: string, value: any) => Promise<void> | void;
     onProviderSourceConfigChanged?: () => Promise<void> | void;
     gitCommandServices?: GitCommandServices;
+    /** Fired synchronously before send_chat is dispatched; fire-and-forget for callers */
+    onBeforeSendChat?: (params: {
+        workspace: string;
+        sessionId: string;
+    }) => void;
 }
 /**
  * Shared helpers interface — passed to sub-module command functions

package/dist/git/git-commands.d.ts

@@ -22,6 +22,16 @@ export interface GitLogResult extends GitRepoIdentity {
     truncated: boolean;
     lastCheckedAt: number;
 }
+export interface GitCheckpointResult extends GitRepoIdentity {
+    commit: string;
+    message: string;
+    lastCheckedAt: number;
+}
+export interface GitStashPushResult extends GitRepoIdentity {
+    stashRef: string;
+    message: string;
+    lastCheckedAt: number;
+}
 export interface GitCommandServices {
     getStatus?: (params: {
         workspace: string;
@@ -53,6 +63,33 @@ export interface GitCommandServices {
         since?: string;
         until?: string;
     }) => Promise<GitLogResult> | GitLogResult;
+    checkpoint?: (params: {
+        workspace: string;
+        message: string;
+        includeUntracked?: boolean;
+    }) => Promise<GitCheckpointResult> | GitCheckpointResult;
+    stashPush?: (params: {
+        workspace: string;
+        message: string;
+        includeUntracked?: boolean;
+    }) => Promise<GitStashPushResult> | GitStashPushResult;
+    stashPop?: (params: {
+        workspace: string;
+        stashRef?: string;
+    }) => Promise<void>;
+    checkoutFiles?: (params: {
+        workspace: string;
+        paths: string[];
+    }) => Promise<{
+        checkedOut: string[];
+    }>;
+    getRemoteUrl?: (params: {
+        workspace: string;
+        remote?: string;
+    }) => Promise<{
+        remoteUrl: string;
+        remote: string;
+    }>;
 }
 type GitCommandFailure = {
     success: false;
@@ -77,6 +114,22 @@ type GitCommandSuccess = {
 } | {
     success: true;
     log: GitLogResult;
+} | {
+    success: true;
+    checkpoint: GitCheckpointResult;
+} | {
+    success: true;
+    stash: GitStashPushResult;
+} | {
+    success: true;
+    stashPopped: true;
+} | {
+    success: true;
+    checkedOut: string[];
+} | {
+    success: true;
+    remoteUrl: string;
+    remote: string;
 };
 export type GitCommandResult = GitCommandSuccess | GitCommandFailure;
 export declare function createDefaultGitCommandServices(): GitCommandServices;

package/dist/git/git-types.d.ts

@@ -110,4 +110,4 @@ export interface GitWorkspaceUpdate {
     seq: number;
     timestamp: number;
 }
-export type GitCommandName = 'git_status' | 'git_diff_summary' | 'git_diff_file' | 'git_snapshot_create' | 'git_snapshot_compare' | 'git_log' | 'git_checkpoint' | 'git_stash_push' | 'git_stash_pop' | 'git_checkout_files';
+export type GitCommandName = 'git_status' | 'git_diff_summary' | 'git_diff_file' | 'git_snapshot_create' | 'git_snapshot_compare' | 'git_log' | 'git_checkpoint' | 'git_stash_push' | 'git_stash_pop' | 'git_checkout_files' | 'git_remote_url';

package/dist/git/index.d.ts

@@ -12,3 +12,5 @@ export { createGitWorkspaceMonitor, DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS, GitW
 export type { GitWorkspaceCacheEntry, GitWorkspaceMonitorOptions, GitWorkspaceSubscription, GitWorkspaceUpdateListener, NormalizedWorkspaceGitSubscriptionParams, NormalizeGitWorkspaceSubscriptionOptions, } from './git-monitor.js';
 export { createDefaultGitCommandServices, handleGitCommand, isGitCommandName } from './git-commands.js';
 export type { GitCommandResult, GitCommandServices, GitFileDiff, GitLogEntry, GitLogResult, } from './git-commands.js';
+export { TurnSnapshotTracker } from './turn-snapshot-tracker.js';
+export type { TurnCompletedCallback } from './turn-snapshot-tracker.js';

package/dist/git/turn-snapshot-tracker.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tracks agent session status transitions and fires snapshot callbacks on turn completion.
+ * "Busy" = streaming | waiting_approval
+ * "Completed" = idle | error (transition from busy)
+ */
+export type TurnCompletedCallback = (params: {
+    sessionId: string;
+    workspace: string;
+}) => void;
+export declare class TurnSnapshotTracker {
+    private lastStatus;
+    private onTurnCompleted;
+    constructor(onTurnCompleted: TurnCompletedCallback);
+    record(sessionId: string, status: string, workspace: string | null | undefined): void;
+    forget(sessionId: string): void;
+}

package/dist/index.js

@@ -1942,6 +1942,7 @@ function resolveCliAdapterConfig(provider) {
     sendDelayMs: typeof provider.sendDelayMs === "number" ? Math.max(0, provider.sendDelayMs) : 0,
     sendKey: typeof provider.sendKey === "string" && provider.sendKey.length > 0 ? provider.sendKey : "\r",
     submitStrategy: provider.submitStrategy === "immediate" ? "immediate" : "wait_for_echo",
+    requirePromptEchoBeforeSubmit: provider.requirePromptEchoBeforeSubmit === true,
     providerResolutionMeta: {
       type: provider.type,
       name: provider.name,
@@ -2207,6 +2208,7 @@ var init_provider_cli_adapter = __esm({
         this.sendDelayMs = resolvedConfig.sendDelayMs;
         this.sendKey = resolvedConfig.sendKey;
         this.submitStrategy = resolvedConfig.submitStrategy;
+        this.requirePromptEchoBeforeSubmit = resolvedConfig.requirePromptEchoBeforeSubmit;
         this.providerResolutionMeta = resolvedConfig.providerResolutionMeta;
         this.cliScripts = provider.scripts || {};
         const scriptNames = listCliScriptNames(this.cliScripts);
@@ -2303,6 +2305,12 @@ var init_provider_cli_adapter = __esm({
       accumulatedRawBuffer = "";
       /** Current visible terminal screen snapshot */
       terminalScreen = new TerminalScreen(24, 80);
+      static MAX_RESPONSE_BUFFER = 8e3;
+      static MAX_RECENT_OUTPUT_BUFFER = 1e3;
+      responseBufferDroppedChars = 0;
+      recentOutputDroppedChars = 0;
+      accumulatedBufferDroppedChars = 0;
+      accumulatedRawBufferDroppedChars = 0;
       /** Max accumulated buffer size. Sized to comfortably hold a single long
        *  Hermes turn (tool calls + reasoning + final bubble) without the
        *  rolling window pushing the turn's ╭─ opening line out of view. */
@@ -2320,6 +2328,23 @@ var init_provider_cli_adapter = __esm({
       providerResolutionMeta;
       static FINISH_RETRY_DELAY_MS = 300;
       static MAX_FINISH_RETRIES = 2;
+      getBufferState() {
+        const build = (droppedChars, maxChars) => droppedChars > 0 ? { truncated: true, droppedChars, maxChars } : void 0;
+        const responseBuffer = build(this.responseBufferDroppedChars, _ProviderCliAdapter.MAX_RESPONSE_BUFFER);
+        const recentOutputBuffer = build(this.recentOutputDroppedChars, _ProviderCliAdapter.MAX_RECENT_OUTPUT_BUFFER);
+        const accumulatedBuffer = build(this.accumulatedBufferDroppedChars, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        const accumulatedRawBuffer = build(this.accumulatedRawBufferDroppedChars, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        if (!responseBuffer && !recentOutputBuffer && !accumulatedBuffer && !accumulatedRawBuffer) return void 0;
+        return {
+          ...responseBuffer ? { responseBuffer } : {},
+          ...recentOutputBuffer ? { recentOutputBuffer } : {},
+          ...accumulatedBuffer ? { accumulatedBuffer } : {},
+          ...accumulatedRawBuffer ? { accumulatedRawBuffer } : {}
+        };
+      }
+      recordBoundedAppendDrop(previousLength, appendedLength, nextLength) {
+        return Math.max(0, previousLength + appendedLength - nextLength);
+      }
       buildCommittedMessagesActivitySignature() {
         const last = this.committedMessages[this.committedMessages.length - 1];
         return [
@@ -2503,6 +2528,7 @@ var init_provider_cli_adapter = __esm({
       sendDelayMs;
       sendKey;
       submitStrategy;
+      requirePromptEchoBeforeSubmit;
       static SCRIPT_STATUS_DEBOUNCE_MS = 3e3;
       /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
       setCliScripts(scripts) {
@@ -2684,7 +2710,9 @@ var init_provider_cli_adapter = __esm({
           this.scheduleStartupSettleCheck();
         }
         if (this.isWaitingForResponse && cleanData) {
-          this.responseBuffer = appendBoundedText(this.responseBuffer, cleanData, 8e3);
+          const previousResponseLen = this.responseBuffer.length;
+          this.responseBuffer = appendBoundedText(this.responseBuffer, cleanData, _ProviderCliAdapter.MAX_RESPONSE_BUFFER);
+          this.responseBufferDroppedChars += this.recordBoundedAppendDrop(previousResponseLen, cleanData.length, this.responseBuffer.length);
         }
         if (cleanData.trim()) {
           if (this.serverConn) {
@@ -2693,14 +2721,19 @@ var init_provider_cli_adapter = __esm({
             this.logBuffer.push({ message: cleanData.trim(), level: "info" });
           }
         }
+        const prevRecentLen = this.recentOutputBuffer.length;
         const prevAccumulatedLen = this.accumulatedBuffer.length;
         const prevAccumulatedRawLen = this.accumulatedRawBuffer.length;
-        this.recentOutputBuffer = appendBoundedText(this.recentOutputBuffer, cleanData, 1e3);
+        this.recentOutputBuffer = appendBoundedText(this.recentOutputBuffer, cleanData, _ProviderCliAdapter.MAX_RECENT_OUTPUT_BUFFER);
         this.accumulatedBuffer = appendBoundedText(this.accumulatedBuffer, cleanData, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
         this.accumulatedRawBuffer = appendBoundedText(this.accumulatedRawBuffer, rawData, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        const droppedRecent = this.recordBoundedAppendDrop(prevRecentLen, cleanData.length, this.recentOutputBuffer.length);
+        const droppedClean = this.recordBoundedAppendDrop(prevAccumulatedLen, cleanData.length, this.accumulatedBuffer.length);
+        const droppedRaw = this.recordBoundedAppendDrop(prevAccumulatedRawLen, rawData.length, this.accumulatedRawBuffer.length);
+        this.recentOutputDroppedChars += droppedRecent;
+        this.accumulatedBufferDroppedChars += droppedClean;
+        this.accumulatedRawBufferDroppedChars += droppedRaw;
         if (this.currentTurnScope) {
-          const droppedClean = prevAccumulatedLen + cleanData.length - this.accumulatedBuffer.length;
-          const droppedRaw = prevAccumulatedRawLen + rawData.length - this.accumulatedRawBuffer.length;
           if (droppedClean > 0) {
             this.currentTurnScope.bufferStart = Math.max(0, this.currentTurnScope.bufferStart - droppedClean);
           }
@@ -3530,13 +3563,15 @@ var init_provider_cli_adapter = __esm({
             effectiveModal = parsedModal;
           }
         }
+        const bufferState = this.getBufferState();
         return {
           status: effectiveStatus,
           messages: [...this.committedMessages],
           workingDir: this.workingDir,
           activeModal: effectiveModal,
           errorMessage: this.parseErrorMessage || void 0,
-          errorReason: this.parseErrorMessage ? "parse_error" : void 0
+          errorReason: this.parseErrorMessage ? "parse_error" : void 0,
+          ...bufferState ? { bufferState } : {}
         };
       }
       seedCommittedMessages(messages) {
@@ -3718,10 +3753,12 @@ var init_provider_cli_adapter = __esm({
             messages: hydratedMessages,
             activeModal: parsed.activeModal ?? this.activeModal,
             providerSessionId: typeof parsed.providerSessionId === "string" ? parsed.providerSessionId : void 0,
+            ...this.getBufferState() ? { bufferState: this.getBufferState() } : {},
             ...this.providerOwnsTranscript() ? { transcriptAuthority: "provider", coverage: this.shouldUseFullProviderTranscriptContext() ? "full" : "tail" } : {}
           };
         } else {
           const messages = [...this.committedMessages];
+          const bufferState = this.getBufferState();
           result = {
             id: "cli_session",
             status: this.currentStatus,
@@ -3732,7 +3769,8 @@ var init_provider_cli_adapter = __esm({
               index: typeof message.index === "number" ? message.index : index,
               receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
             })),
-            activeModal: this.activeModal
+            activeModal: this.activeModal,
+            ...bufferState ? { bufferState } : {}
           };
         }
         const hasVisibleAssistantMessage = Array.isArray(result?.messages) && result.messages.some((message) => message?.role === "assistant" && typeof message?.content === "string" && message.content.trim());
@@ -4023,6 +4061,22 @@ var init_provider_cli_adapter = __esm({
           }
         }
         if (elapsed >= state.maxEchoWaitMs) {
+          const diagnostic = {
+            elapsed,
+            maxEchoWaitMs: state.maxEchoWaitMs,
+            submitDelayMs: state.submitDelayMs,
+            promptSnippet: state.normalizedPromptSnippet,
+            requirePromptEchoBeforeSubmit: this.requirePromptEchoBeforeSubmit,
+            screenText: summarizeCliTraceText(screenText, 1e3)
+          };
+          this.recordTrace("submit_echo_missing", diagnostic);
+          if (this.requirePromptEchoBeforeSubmit) {
+            const message = `${this.cliName} prompt echo was not observed on the PTY screen before submit`;
+            LOG.warn("CLI", `[${this.cliType}] ${message} elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs} screen=${JSON.stringify(diagnostic.screenText).slice(0, 240)}`);
+            completion.rejectOnce(new Error(message));
+            return;
+          }
+          LOG.warn("CLI", `[${this.cliType}] prompt echo was not observed before submit; sending submit key anyway elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs}`);
           this.submitSendKey(state, completion);
           return;
         }
@@ -4487,6 +4541,7 @@ var init_provider_cli_adapter = __esm({
           sendDelayMs: this.sendDelayMs,
           sendKey: this.sendKey,
           submitStrategy: this.submitStrategy,
+          requirePromptEchoBeforeSubmit: this.requirePromptEchoBeforeSubmit,
           submitPendingUntil: this.submitPendingUntil,
           responseSettleIgnoreUntil: this.responseSettleIgnoreUntil,
           resizeSuppressUntil: this.resizeSuppressUntil,
@@ -4574,6 +4629,7 @@ __export(index_exports, {
   ProviderLoader: () => ProviderLoader,
   STANDALONE_CDP_SCAN_INTERVAL_MS: () => STANDALONE_CDP_SCAN_INTERVAL_MS,
   SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory,
+  TurnSnapshotTracker: () => TurnSnapshotTracker,
   VersionArchive: () => VersionArchive,
   appendRecentActivity: () => appendRecentActivity,
   buildAssistantChatMessage: () => buildAssistantChatMessage,
@@ -5585,13 +5641,8 @@ var GIT_COMMAND_NAMES = /* @__PURE__ */ new Set([
   "git_checkpoint",
   "git_stash_push",
   "git_stash_pop",
-  "git_checkout_files"
-]);
-var MUTATING_COMMAND_NAMES = /* @__PURE__ */ new Set([
-  "git_checkpoint",
-  "git_stash_push",
-  "git_stash_pop",
-  "git_checkout_files"
+  "git_checkout_files",
+  "git_remote_url"
 ]);
 var SNAPSHOT_REASONS = /* @__PURE__ */ new Set([
   "session_baseline",
@@ -5632,7 +5683,12 @@ function createDefaultGitCommandServices() {
       turnId
     }),
     compareSnapshots: ({ beforeSnapshotId, afterSnapshotId }) => defaultSnapshotStore.compare(beforeSnapshotId, afterSnapshotId),
-    getLog: ({ workspace, limit, path: filePath, since, until }) => getGitLog(workspace, { limit, path: filePath, since, until })
+    getLog: ({ workspace, limit, path: filePath, since, until }) => getGitLog(workspace, { limit, path: filePath, since, until }),
+    checkpoint: async ({ workspace, message, includeUntracked = false }) => gitCheckpoint(workspace, message, includeUntracked),
+    stashPush: async ({ workspace, message, includeUntracked = false }) => gitStashPush(workspace, message, includeUntracked),
+    stashPop: async ({ workspace, stashRef }) => gitStashPop(workspace, stashRef),
+    checkoutFiles: async ({ workspace, paths }) => gitCheckoutFiles(workspace, paths),
+    getRemoteUrl: async ({ workspace, remote = "origin" }) => gitGetRemoteUrl(workspace, remote)
   };
 }
 var defaultGitCommandServices = createDefaultGitCommandServices();
@@ -5696,9 +5752,6 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
   if (!isGitCommandName(command)) {
     return failure("invalid_args", `Unknown Git command: ${command}`);
   }
-  if (MUTATING_COMMAND_NAMES.has(command)) {
-    return failure("invalid_args", `${command} is not implemented in daemon-core read-only Git routing`);
-  }
   const workspaceResult = validateWorkspace2(args);
   if ("success" in workspaceResult) return workspaceResult;
   const { workspace } = workspaceResult;
@@ -5758,10 +5811,153 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
       }));
       return "success" in log ? log : { success: true, log };
     }
+    case "git_checkpoint": {
+      if (!services.checkpoint) return serviceNotImplemented(command);
+      const msg = validateMutatingMessage(args?.message);
+      if (typeof msg !== "string") return msg;
+      const includeUntracked = Boolean(args?.includeUntracked);
+      const checkpoint = await runService(() => services.checkpoint({ workspace, message: msg, includeUntracked }));
+      return "success" in checkpoint ? checkpoint : { success: true, checkpoint };
+    }
+    case "git_stash_push": {
+      if (!services.stashPush) return serviceNotImplemented(command);
+      const msg = validateMutatingMessage(args?.message);
+      if (typeof msg !== "string") return msg;
+      const includeUntracked = Boolean(args?.includeUntracked);
+      const stash = await runService(() => services.stashPush({ workspace, message: msg, includeUntracked }));
+      return "success" in stash ? stash : { success: true, stash };
+    }
+    case "git_stash_pop": {
+      if (!services.stashPop) return serviceNotImplemented(command);
+      const stashRef = optionalString(args?.stashRef);
+      if (stashRef !== void 0 && !/^stash@\{\d+\}$/.test(stashRef)) {
+        return failure("invalid_args", "stashRef must match stash@{N} format");
+      }
+      const popResult = await runService(() => services.stashPop({ workspace, stashRef }));
+      if (popResult !== void 0 && "success" in popResult) return popResult;
+      return { success: true, stashPopped: true };
+    }
+    case "git_checkout_files": {
+      if (!services.checkoutFiles) return serviceNotImplemented(command);
+      const paths = args?.paths;
+      if (!Array.isArray(paths) || paths.length === 0) {
+        return failure("invalid_args", "paths must be a non-empty array");
+      }
+      if (paths.length > 50) {
+        return failure("invalid_args", "paths array exceeds maximum of 50 entries");
+      }
+      const checkoutResult = await runService(() => services.checkoutFiles({ workspace, paths }));
+      return "success" in checkoutResult ? checkoutResult : { success: true, checkedOut: checkoutResult.checkedOut };
+    }
+    case "git_remote_url": {
+      if (!services.getRemoteUrl) return serviceNotImplemented(command);
+      const remote = typeof args?.remote === "string" && args.remote.trim() ? args.remote.trim() : "origin";
+      const remoteResult = await runService(() => services.getRemoteUrl({ workspace, remote }));
+      if ("success" in remoteResult) return remoteResult;
+      return { success: true, remoteUrl: remoteResult.remoteUrl, remote: remoteResult.remote };
+    }
     default:
       return failure("invalid_args", `Unknown Git command: ${command}`);
   }
 }
+function validateMutatingMessage(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return failure("invalid_args", "message must be a non-empty string");
+  }
+  const msg = value.trim();
+  if (msg.length > 200) {
+    return failure("invalid_args", "message must be 200 characters or fewer");
+  }
+  return msg;
+}
+async function gitCheckpoint(workspace, message, includeUntracked) {
+  const repo = await resolveGitRepository(workspace);
+  const repoRoot = repo.repoRoot;
+  const statusResult = await getGitRepoStatus(workspace);
+  if (statusResult.hasConflicts) {
+    throw new GitCommandError("conflict", "Repository has conflicts \u2014 resolve before checkpointing");
+  }
+  const addArgs = includeUntracked ? ["-A"] : ["-u"];
+  await runGit(repo, ["add", ...addArgs], { cwd: repoRoot });
+  const fullMsg = `adhdev: checkpoint ${message}`;
+  let commitSha;
+  try {
+    await runGit(repo, ["commit", "-m", fullMsg], { cwd: repoRoot });
+    const revResult = await runGit(repo, ["rev-parse", "HEAD"], { cwd: repoRoot });
+    commitSha = revResult.stdout.trim();
+  } catch (err) {
+    const output = (err?.stdout || "") + (err?.stderr || "");
+    if (/nothing to commit/i.test(output)) {
+      throw new GitCommandError("git_command_failed", "Nothing to commit");
+    }
+    throw err;
+  }
+  return {
+    workspace: repo.workspace,
+    repoRoot,
+    isGitRepo: true,
+    commit: commitSha,
+    message: fullMsg,
+    lastCheckedAt: Date.now()
+  };
+}
+async function gitStashPush(workspace, message, includeUntracked) {
+  const repo = await resolveGitRepository(workspace);
+  const repoRoot = repo.repoRoot;
+  const stashArgs = ["stash", "push", "-m", message];
+  if (includeUntracked) stashArgs.push("--include-untracked");
+  const result = await runGit(repo, stashArgs, { cwd: repoRoot });
+  if (/No local changes to save/i.test(result.stdout + result.stderr)) {
+    throw new GitCommandError("git_command_failed", "Nothing to stash");
+  }
+  return {
+    workspace: repo.workspace,
+    repoRoot,
+    isGitRepo: true,
+    stashRef: "stash@{0}",
+    message,
+    lastCheckedAt: Date.now()
+  };
+}
+async function gitStashPop(workspace, stashRef) {
+  const repo = await resolveGitRepository(workspace);
+  const repoRoot = repo.repoRoot;
+  const popArgs = stashRef ? ["stash", "pop", stashRef] : ["stash", "pop"];
+  await runGit(repo, popArgs, { cwd: repoRoot });
+}
+async function gitCheckoutFiles(workspace, paths) {
+  const repo = await resolveGitRepository(workspace);
+  const repoRoot = repo.repoRoot;
+  const normalizedPaths = [];
+  for (const p of paths) {
+    if (typeof p !== "string" || !p.trim() || p.includes("\0")) {
+      throw new GitCommandError("invalid_args", `Invalid path: ${String(p)}`);
+    }
+    if (path3.isAbsolute(p)) {
+      throw new GitCommandError("invalid_args", `Path must be repository-relative, not absolute: ${p}`);
+    }
+    const normalized = path3.normalize(p.trim()).split(path3.sep).join("/");
+    if (normalized.startsWith("../") || normalized === "..") {
+      throw new GitCommandError("path_outside_repo", `Path is outside repository root: ${p}`);
+    }
+    const absolutePath = path3.resolve(repoRoot, normalized);
+    if (!isPathInside(repoRoot, absolutePath)) {
+      throw new GitCommandError("path_outside_repo", `Path is outside repository root: ${p}`);
+    }
+    normalizedPaths.push(normalized);
+  }
+  await runGit(repo, ["checkout", "--", ...normalizedPaths], { cwd: repoRoot });
+  return { checkedOut: normalizedPaths };
+}
+async function gitGetRemoteUrl(workspace, remote) {
+  const repo = await resolveGitRepository(workspace);
+  const result = await runGit(repo, ["remote", "get-url", remote], { cwd: repo.repoRoot });
+  const remoteUrl = result.stdout.trim();
+  if (!remoteUrl) {
+    throw new GitCommandError("git_command_failed", `Remote '${remote}' has no URL`);
+  }
+  return { remoteUrl, remote };
+}
 function formatOptionalGitLogRangeArg(flag, value) {
   return value ? [`${flag}=${value}`] : [];
 }
@@ -5820,6 +6016,27 @@ function validateGitLogPath(repoRoot, filePath) {
   return normalized;
 }
 
+// src/git/turn-snapshot-tracker.ts
+var BUSY_STATUSES = /* @__PURE__ */ new Set(["streaming", "waiting_approval"]);
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["idle", "error"]);
+var TurnSnapshotTracker = class {
+  lastStatus = /* @__PURE__ */ new Map();
+  onTurnCompleted;
+  constructor(onTurnCompleted) {
+    this.onTurnCompleted = onTurnCompleted;
+  }
+  record(sessionId, status, workspace) {
+    const prev = this.lastStatus.get(sessionId);
+    this.lastStatus.set(sessionId, status);
+    if (workspace && prev && BUSY_STATUSES.has(prev) && TERMINAL_STATUSES.has(status)) {
+      this.onTurnCompleted({ sessionId, workspace });
+    }
+  }
+  forget(sessionId) {
+    this.lastStatus.delete(sessionId);
+  }
+};
+
 // src/index.ts
 init_config();
 
@@ -14707,6 +14924,16 @@ var DaemonCommandHandler = class {
         return result;
       }
     }
+    if (cmd === "send_chat" && this._ctx.onBeforeSendChat) {
+      const sessionId = this._currentRoute.session?.sessionId;
+      const workspace = sessionId ? this._ctx.instanceManager?.getInstance(sessionId)?.getState?.()?.workspace : void 0;
+      if (workspace && sessionId) {
+        try {
+          this._ctx.onBeforeSendChat({ workspace, sessionId });
+        } catch {
+        }
+      }
+    }
     try {
       result = await this.dispatch(cmd, args);
       this.logCommandEnd(cmd, result, startedAt);
@@ -17942,6 +18169,7 @@ var KNOWN_PROVIDER_FIELDS = /* @__PURE__ */ new Set([
   "sendDelayMs",
   "sendKey",
   "submitStrategy",
+  "requirePromptEchoBeforeSubmit",
   "timeouts",
   "disableUpstream"
 ]);
@@ -29461,6 +29689,7 @@ async function initDaemonComponents(config) {
     providerLoader,
     instanceManager,
     sessionRegistry,
+    gitCommandServices: createDefaultGitCommandServices(),
     onProviderSettingChanged: async (providerType) => {
       await refreshProviderAvailability(providerType);
       config.onStatusChange?.();
@@ -29468,7 +29697,8 @@ async function initDaemonComponents(config) {
     onProviderSourceConfigChanged: async () => {
       await refreshProviderAvailability();
       config.onStatusChange?.();
-    }
+    },
+    onBeforeSendChat: config.onBeforeSendChat
   });
   agentStreamManager = new DaemonAgentStreamManager(
     LOG.forComponent("AgentStream").asLogFn(),
@@ -29620,6 +29850,7 @@ async function shutdownDaemonComponents(components) {
   ProviderLoader,
   STANDALONE_CDP_SCAN_INTERVAL_MS,
   SessionHostPtyTransportFactory,
+  TurnSnapshotTracker,
   VersionArchive,
   appendRecentActivity,
   buildAssistantChatMessage,