@adhdev/daemon-core 0.9.82-rc.377 → 0.9.82-rc.379

package/dist/mesh/mesh-refine-gates.d.ts

@@ -0,0 +1,428 @@
+/**
+ * Mesh refine validation gates & gitlink fast-forward evaluation
+ *
+ * Extracted from commands/router.ts (behavior-preserving move). Contains:
+ *   - the MeshCoordinator config-format type
+ *   - refine validation / patch-equivalence / effective-diff / submodule
+ *     reachability gates and their summary types + job handles
+ *   - gitlink trivial-fast-forward evaluation and submodule alignment helpers
+ *
+ * router.ts re-exports every public symbol from here so existing import paths
+ * keep working. `CommandRouterResult` is imported type-only from router.ts
+ * (erased at compile time — no runtime import cycle).
+ */
+import type { WorktreeBootstrapState } from '../mesh/worktree-bootstrap-config.js';
+import type { CommandRouterResult } from '../commands/router.js';
+export type MeshCoordinatorConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
+type MeshRefineValidationStatus = 'passed' | 'failed' | 'skipped';
+type MeshRefineValidationSummary = {
+    status: MeshRefineValidationStatus;
+    required: true;
+    commandsRun: Array<Record<string, unknown>>;
+    bootstrapCommandsRun: Array<Record<string, unknown>>;
+    rejectedCommands: Array<Record<string, unknown>>;
+    skippedReason?: string;
+    failureKind?: string;
+    failureCode?: string;
+    /** Human-readable cause when failureKind === 'spawn_resolution_failed' (win32 .cmd shim, etc). */
+    spawnResolutionError?: string;
+    timeoutMs: number;
+    outputLimitBytes: number;
+    configSource?: string;
+    configSourceType?: string;
+    suggestions?: unknown[];
+    suggestedConfig?: unknown;
+    /**
+     * M2-3: the bootstrap stage recorded separately from validation so review
+     * surfaces can distinguish environment failures from validation failures.
+     *   cached — worktree_bootstrap was 'ready' (staleInputs unchanged), skipped
+     *   ran    — worktree_bootstrap was stale/never-ran and re-ran successfully
+     *   failed — bootstrap run failed (refine stops before validation)
+     *   skipped — refine config validation.bootstrap === 'skip'
+     *   legacy — deprecated validation.bootstrapCommands path was used
+     *   not_configured — no bootstrap definition anywhere
+     */
+    bootstrap?: {
+        stage: 'cached' | 'ran' | 'failed' | 'skipped' | 'legacy' | 'not_configured';
+        status?: string;
+        skipped?: boolean;
+        configSource?: string;
+        staleReason?: string;
+        error?: string;
+        commandsRun?: Array<Record<string, unknown>>;
+    };
+    /** M2-2: deprecation notices from the refine config (e.g. bootstrapCommands). */
+    deprecationWarnings?: string[];
+};
+type MeshRefineStageStatus = 'passed' | 'failed' | 'skipped';
+type MeshRefinePatchEquivalenceSummary = {
+    status: MeshRefineStageStatus;
+    equivalent: boolean;
+    baseHead: string;
+    branchHead: string;
+    mergeBase?: string;
+    mergedTree?: string;
+    expectedPatchId?: string;
+    actualPatchId?: string;
+    durationMs: number;
+    error?: string;
+    stdout?: string;
+    stderr?: string;
+    actionableHint?: MeshRefineSubmoduleConflictHint;
+    /**
+     * Set when a `merge-tree` submodule conflict was reclassified as a trivial
+     * gitlink fast-forward and the gate passed via a synthesized merge tree.
+     */
+    gitlinkTrivialFastForward?: {
+        resolved: boolean;
+        gitlinks: Array<{
+            path: string;
+            baseCommit?: string;
+            branchCommit?: string;
+            fastForward: boolean;
+        }>;
+        reason?: string;
+    };
+};
+type MeshRefineEffectiveDiffSummary = {
+    status: MeshRefineStageStatus;
+    /** True when there is at least one root-tree change between base and branch (incl. gitlink bumps). */
+    hasEffectiveDiff: boolean;
+    baseHead: string;
+    branchHead: string;
+    /** Root-level paths that differ between base and branch (capped). */
+    changedPaths?: string[];
+    /** Submodule paths with uncommitted/divergent commits but NO committed gitlink bump in the root tree. */
+    submoduleHints?: Array<{
+        path: string;
+        reason: string;
+    }>;
+    durationMs: number;
+    error?: string;
+    stdout?: string;
+    stderr?: string;
+};
+type MeshRefineSubmoduleConflictHint = {
+    kind: 'submodule_conflict';
+    message: string;
+    conflicts: Array<{
+        path: string;
+        baseCommit?: string;
+        branchCommit?: string;
+    }>;
+    nextSteps: string[];
+};
+type MeshRefineSubmoduleAlignmentSummary = {
+    status: 'passed' | 'failed' | 'skipped';
+    changedGitlinkPaths: string[];
+    outOfSyncPaths: string[];
+    updatedPaths: string[];
+    verifiedPaths: string[];
+    durationMs: number;
+    reason?: string;
+    command?: string;
+    error?: string;
+    stdout?: string;
+    stderr?: string;
+};
+type MeshRefineSubmoduleReachabilityEntry = {
+    path: string;
+    commit: string;
+    reachable: boolean;
+    publishRequired?: boolean;
+    autoPublishAllowed?: boolean;
+    autoPublishAttempted?: boolean;
+    autoPublishSucceeded?: boolean;
+    autoPublishVerified?: boolean;
+    autoPublishRefspec?: string;
+    autoPublishSkippedReason?: string;
+    importedFromWorktree?: boolean;
+    checkedLocal?: boolean;
+    localReachable?: boolean;
+    remote?: string;
+    remoteUrl?: string;
+    remoteReachable?: boolean;
+    remoteMainBranch?: string;
+    remoteMainReachable?: boolean;
+    fetchedFromOrigin?: boolean;
+    error?: string;
+    publishStdout?: string;
+    publishStderr?: string;
+};
+type MeshRefineSubmoduleReachabilitySummary = {
+    status: MeshRefineStageStatus;
+    checked: number;
+    unreachable: MeshRefineSubmoduleReachabilityEntry[];
+    entries: MeshRefineSubmoduleReachabilityEntry[];
+    durationMs: number;
+    autoPublishAllowed?: boolean;
+    autoPublishPolicySource?: string;
+    error?: string;
+};
+export type MeshRefineAsyncJobStatus = 'accepted' | 'completed' | 'failed';
+export type MeshRefineJobHandle = {
+    success: true;
+    async: true;
+    status: MeshRefineAsyncJobStatus;
+    jobId: string;
+    interactionId: string;
+    meshId: string;
+    nodeId: string;
+    targetNodeId: string;
+    targetDaemonId?: string;
+    workspace?: string;
+    startedAt: string;
+    completedAt?: string;
+    duplicate?: boolean;
+    retryOfJobId?: string;
+    /**
+     * The coordinator daemon ID that initiated this refine job.
+     * When set, events for this job are scoped to that coordinator's
+     * pending-events queue instead of the shared broadcast queue.
+     */
+    targetCoordinatorDaemonId?: string;
+    eventDelivery: {
+        pendingEvents: true;
+        ledger: true;
+    };
+    evidence: {
+        pendingEventsCommand: 'get_pending_mesh_events';
+        ledgerCommand: 'get_mesh_ledger_slice';
+        taskHistoryKind: 'task_dispatched' | 'task_completed' | 'task_failed';
+    };
+};
+export type MeshRefineTerminalJob = MeshRefineJobHandle & {
+    result?: Record<string, unknown>;
+};
+export type MeshRefineBatchJobStatus = 'accepted' | 'completed' | 'failed';
+/**
+ * Async handle returned by the batch Refinery the instant a convergence run is
+ * accepted. Mirrors {@link MeshRefineJobHandle} (async:true / status:'accepted' +
+ * terminal pending-event + ledger delivery) but scopes a whole batch of sibling
+ * nodes rather than a single node. The synthetic `batchLabel` is used as the
+ * `nodeLabel` for the shared refine event/message renderer.
+ */
+export type MeshRefineBatchJobHandle = {
+    success: true;
+    async: true;
+    batch: true;
+    status: MeshRefineBatchJobStatus;
+    jobId: string;
+    interactionId: string;
+    meshId: string;
+    batchLabel: string;
+    nodeIds: string[];
+    nodeCount: number;
+    order: string[];
+    startedAt: string;
+    completedAt?: string;
+    duplicate?: boolean;
+    targetCoordinatorDaemonId?: string;
+    eventDelivery: {
+        pendingEvents: true;
+        ledger: true;
+    };
+    evidence: {
+        pendingEventsCommand: 'get_pending_mesh_events';
+        ledgerCommand: 'get_mesh_ledger_slice';
+        taskHistoryKind: 'task_dispatched' | 'task_completed' | 'task_failed';
+    };
+};
+export type MeshRefineBatchTerminalJob = MeshRefineBatchJobHandle & {
+    result?: Record<string, unknown>;
+};
+export declare function truncateValidationOutput(value: unknown): string;
+/**
+ * A spawn-resolution failure is when the executable itself could not be found by
+ * the OS spawn boundary — `spawn <cmd> ENOENT` — as opposed to the command
+ * running and exiting non-zero. On win32 this is the .cmd-shim case: libuv's
+ * spawn search appends only .com/.exe, so a bare `npm`/`npx`/`tsc` (which are
+ * .cmd shims) ENOENTs even though it is installed. It carries no stderr, so it
+ * must be detected by error.code/syscall, not by string-matching output.
+ */
+export declare function isSpawnResolutionError(error: any): boolean;
+export declare function describeSpawnError(error: any, command: string, spawnResolutionFailed: boolean): string;
+export declare function recordMeshRefineStage(stages: Array<Record<string, unknown>>, stage: string, status: MeshRefineStageStatus, startedAt: number, details?: Record<string, unknown>): void;
+export declare function buildSubmodulePublishRequiredNextStep(entries: MeshRefineSubmoduleReachabilityEntry[]): string;
+/**
+ * Async git exec helper used across the synchronous-refine stage pipeline. Bound
+ * once in the orchestrator and threaded through RefineContext so every stage runs
+ * git the same way (execFile + promisify, utf8). Returns the child's stdout/stderr.
+ */
+export type RefineExecFileAsync = (file: string, args: string[], options: {
+    cwd: string;
+    encoding: 'utf8';
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Accumulated state shared by the synchronous-refine stages. The orchestrator
+ * (executeMeshRefineNodeSynchronously) seeds this in the resolve_refs stage and
+ * each later stage reads / extends it. `branchHead` and `patchEquivalence` are the
+ * only fields a stage mutates after creation (auto-rebase updates both), so they
+ * are carried on the mutable context rather than re-threaded through return types.
+ */
+export interface RefineContext {
+    meshId: string;
+    nodeId: string;
+    args: any;
+    refineStages: Array<Record<string, unknown>>;
+    execFileAsync: RefineExecFileAsync;
+    mesh: any;
+    node: any;
+    sourceNode: any;
+    repoRoot: string;
+    branch: string;
+    baseBranch: string;
+    baseHead: string;
+    branchHead: string;
+    validationSummary: Awaited<ReturnType<typeof runMeshRefineValidationGate>>;
+    patchEquivalence: Awaited<ReturnType<typeof runMeshRefinePatchEquivalenceGate>>;
+    submoduleReachability: Awaited<ReturnType<typeof runMeshRefineSubmoduleReachabilityGate>>;
+}
+/**
+ * Stage outcome for the synchronous-refine pipeline. A stage either produces a
+ * terminal CommandRouterResult (an early-exit gate failure, or a successful
+ * already-merged short-circuit), in which case the orchestrator returns it
+ * immediately, or it returns `continue` with the (possibly extended) context for
+ * the next stage. This makes the orchestrator a flat sequence of stage calls
+ * while preserving the original body's exact early-return control flow.
+ */
+export type RefineStageOutcome = {
+    kind: 'terminal';
+    result: CommandRouterResult;
+} | {
+    kind: 'continue';
+    ctx: RefineContext;
+};
+export declare function resolveRefineryAutoPublishSubmoduleMainCommits(mesh: any, workspace: string): {
+    enabled: boolean;
+    source?: string;
+};
+export declare function runMeshRefinePatchEquivalenceGate(repoRoot: string, baseHead: string, branchHead: string): Promise<MeshRefinePatchEquivalenceSummary>;
+export type MeshWorktreePatchContainmentSummary = {
+    /** True only when merging worktreeHead into ref introduces no new patch. */
+    contained: boolean;
+    ref: string;
+    worktreeHead: string;
+    mergeBase?: string;
+    mergedTree?: string;
+    /** patch-id of (ref -> synthesized merge tree); empty string when nothing new is added. */
+    residualPatchId?: string;
+    durationMs: number;
+    /** Set when the check could not run (treated conservatively as NOT contained). */
+    error?: string;
+};
+/**
+ * Patch-equivalence containment check for the worktree force-cleanup convergence
+ * guard. Answers a narrower question than {@link runMeshRefinePatchEquivalenceGate}:
+ * "are the worktree branch's changes ALREADY present in `ref` (e.g. origin/main),
+ * even though the worktree HEAD's commit SHA is not an ancestor of ref?"
+ *
+ * This is the cherry-pick / squash / rebase case: the same content landed on the
+ * default ref under a different commit SHA, so `merge-base --is-ancestor` (the
+ * primary cleanup guard) reports the worktree as un-converged and refuses to
+ * remove it. Refinery already accepts patch-equivalent landings via merge-tree +
+ * patch-id; this brings the same notion of "convergence" to the cleanup guard.
+ *
+ * Mechanism: synthesize the merge of `worktreeHead` into `ref` (reusing the same
+ * trivial-gitlink-fast-forward handling as the refine gate) and compute the
+ * patch-id of (ref -> mergedTree). If that residual diff is EMPTY, merging the
+ * worktree adds nothing new on top of ref — its changes are already present there
+ * and the worktree is safe to remove. A non-empty residual means the worktree
+ * still carries content not in ref, so it is NOT contained and must stay blocked.
+ *
+ * Conservative by construction: any merge-tree / patch-id failure, a genuine
+ * (non-trivial) submodule conflict, or any thrown error yields `contained: false`
+ * so an exception can never widen the cleanup allow-list.
+ */
+export declare function checkWorktreeChangesPatchEquivalentInRef(repoRoot: string, ref: string, worktreeHead: string): Promise<MeshWorktreePatchContainmentSummary>;
+/**
+ * No-op guard: detect a "silent no-op" merge before the Refinery merge runs.
+ *
+ * A silent no-op occurs when the refine target branch's ROOT tree is byte-identical
+ * to the merge base (origin/main). This is the trap where a submodule (e.g. oss) has
+ * real commits but the root branch never committed the gitlink (oss-pointer) bump, so
+ * the root diff Refinery would merge is empty. Merging that produces a merge commit with
+ * no content change — reported as "success" while the actual work never reaches main.
+ *
+ * A committed gitlink bump (the legitimate oss-pointer bump) DOES show up in the root
+ * tree diff (as a 160000-mode entry), so this guard does NOT block legitimate refines —
+ * it only fires when the root tree diff vs base is COMPLETELY empty.
+ *
+ * Runs after the patch-equivalence gate; the "already merged via other path" case
+ * (branch has real changes already present in base) is handled upstream and never
+ * reaches here, so an empty root diff at this point is genuinely a no-op.
+ */
+export declare function runMeshRefineEffectiveDiffGate(repoRoot: string, baseHead: string, branchHead: string): Promise<MeshRefineEffectiveDiffSummary>;
+/**
+ * Result of evaluating whether a `git merge-tree --write-tree` submodule
+ * conflict is in fact a trivial gitlink fast-forward that should pass the
+ * patch-equivalence gate.
+ *
+ * `git merge-tree` (and `git merge` with the default recursive strategy)
+ * refuses to 3-way merge gitlinks unless the case is "trivial" — and it
+ * treats *any* gitlink that differs across merge-base/base/branch as
+ * non-trivial, even when the branch-side commit is a strict descendant of the
+ * base-side commit (i.e. a real fast-forward). Refinery only ever wants to
+ * accept the branch's recorded gitlink, so a fast-forwardable bump is safe to
+ * resolve to the branch side without any conflict.
+ */
+type GitlinkTrivialFastForwardEvaluation = {
+    /** True only when the merge-tree conflict is *fully* explained by trivial-ff gitlinks. */
+    trivial: boolean;
+    /** Why the evaluation declined to treat the conflict as trivial (set when trivial=false). */
+    reason?: string;
+    /** Per-path detail for the changed gitlinks that were inspected. */
+    gitlinks: Array<{
+        path: string;
+        baseCommit?: string;
+        branchCommit?: string;
+        fastForward: boolean;
+    }>;
+};
+/**
+ * Return the changed gitlink paths between base and branch whose advance is a
+ * strict fast-forward (the base-side commit is an ancestor of the branch-side
+ * commit inside that submodule's repo). These are the paths whose patch-id hunk
+ * may legitimately differ when base has advanced the same submodule, so they
+ * are safe to exclude from the patch-equivalence comparison. A non-ff (genuinely
+ * diverged) gitlink is deliberately excluded from this set so it still fails the
+ * gate.
+ */
+export declare function collectFastForwardGitlinkPaths(repoRoot: string, baseHead: string, branchHead: string): string[];
+/**
+ * Decide whether a merge-tree submodule conflict between base and branch is a
+ * trivial gitlink fast-forward (and nothing else).
+ *
+ * The conflict is treated as trivial ONLY when:
+ *   1. at least one changed gitlink exists,
+ *   2. every changed gitlink fast-forwards (base-commit is an ancestor of the
+ *      branch-commit inside that submodule's repo), and
+ *   3. the *only* paths that changed on both sides of the merge (i.e. the paths
+ *      that could possibly produce a 3-way conflict — the intersection of
+ *      mergeBase→base and mergeBase→branch changes) are gitlinks. Any
+ *      overlapping non-gitlink path means a genuine content conflict could be
+ *      hiding behind the submodule failure, so we keep the block.
+ *
+ * If any of these fail, the conflict is left as a genuine block. This never
+ * passes a regular-file conflict or a diverged (non-ff) gitlink.
+ */
+export declare function evaluateGitlinkTrivialFastForward(repoRoot: string, baseHead: string, branchHead: string): GitlinkTrivialFastForwardEvaluation;
+export declare function alignRefinerySubmodulesAfterMerge(repoRoot: string, previousBaseHead: string, currentHead: string, options?: {
+    submoduleIgnorePaths?: string[];
+}): Promise<MeshRefineSubmoduleAlignmentSummary>;
+export declare function runMeshRefineSubmoduleReachabilityGate(repoRoot: string, mergedTree: string, options?: {
+    allowAutoPublishSubmoduleMainCommits?: boolean;
+    autoPublishPolicySource?: string;
+    worktreeRoot?: string;
+}): Promise<MeshRefineSubmoduleReachabilitySummary>;
+export declare function buildMeshRefineValidationPlan(mesh: any, workspace: string): Record<string, unknown>;
+export declare function runMeshRefineValidationGate(mesh: any, workspace: string, opts?: {
+    /** M2-2: persisted node bootstrap state for staleness evaluation. */
+    persistedBootstrapState?: WorktreeBootstrapState | null;
+    /** M2-2: called after an inherit-mode bootstrap run so the caller can persist the new state. */
+    onBootstrapStateChange?: (state: WorktreeBootstrapState) => void;
+}): Promise<MeshRefineValidationSummary>;
+export {};

package/dist/providers/spec/fsm-driver.d.ts

@@ -2,6 +2,7 @@ import { type SpecPtyEvent } from './adapter.js';
 import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
 import { type TraceEntry } from './evaluator.js';
 import { type TransitionEval } from './fsm-evaluator.js';
+import { chunkPreservingSurrogates as chunkPreservingSurrogatesShared } from '../../cli-adapters/pty-write-chunking.js';
 export type DashboardEvent = {
     kind: 'pty_data';
     chunk: string;
@@ -155,10 +156,11 @@ export interface SpecDriverOpts {
     extraCliArgs?: string[];
 }
 export declare function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text: string): number;
-/** Split `text` into chunks of at most `size` UTF-16 units without ever cutting
- *  between a high and low surrogate (which would corrupt an astral char — emoji,
- *  etc. — on the UTF-8 PTY write). */
-export declare function chunkPreservingSurrogates(text: string, size: number): string[];
+/** Re-export of the shared surrogate-safe splitter so existing imports of
+ *  `chunkPreservingSurrogates` from this module keep working. The implementation
+ *  lives in ../../cli-adapters/pty-write-chunking so the spec driver and the
+ *  legacy adapter share one definition. */
+export declare const chunkPreservingSurrogates: typeof chunkPreservingSurrogatesShared;
 export declare function guessExt(mime: string): string;
 type HistoryEntry = DriverHistoryEntry;
 export declare class FsmDriver implements ISpecDriver {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.377",
+  "version": "0.9.82-rc.379",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.377",
+    "@adhdev/mesh-shared": "0.9.82-rc.379",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -27,6 +27,12 @@ import {
     type PtyRuntimeTransport,
     type PtyTransportFactory,
 } from './pty-transport.js';
+import {
+    WIN32_PTY_WRITE_CHUNK_CHARS,
+    WIN32_PTY_WRITE_CHUNK_GAP_MS,
+    chunkPreservingSurrogates,
+    shouldChunkWin32Write,
+} from './pty-write-chunking.js';
 import {
     buildCliScreenSnapshot,
     compactPromptText,
@@ -744,6 +750,11 @@ export class ProviderCliAdapter implements CliAdapter {
             `[${this.cliType}] Startup settled (${trigger}, stableMs=${stableMs}, modal=${!!startupModal}) providerDir=${this.providerResolutionMeta.providerDir || '-'} scriptDir=${this.providerResolutionMeta.scriptDir || '-'} scriptsPath=${this.providerResolutionMeta.scriptsPath || '-'}`
         );
         this.onStatusChange?.();
+        // Readiness barrier flush: a message queued because the session was not yet
+        // ready (sendMessageNow's not_ready_pending_prompt path) has no turn-completion
+        // event to trigger its flush. Now that the interactive prompt is up and we are
+        // idle, drain it. No-op when the queue is empty or we settled to a modal.
+        if (!startupModal) this.schedulePendingOutboundFlush();
     }
 
     private scheduleStartupSettleCheck(): void {
@@ -1153,9 +1164,42 @@ export class ProviderCliAdapter implements CliAdapter {
 
     private async writeToPty(data: string): Promise<void> {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+        // win32 ConPTY paced write: a single unbounded write beyond ~1KB overflows
+        // the console input pipe and drops LEADING bytes (the "long message gets
+        // truncated, head lost / tail kept" failure). Split a large payload into
+        // bounded, surrogate-safe chunks written with a short gap so the console
+        // reader keeps up. Small payloads (the common case — short prompts, lone
+        // submit keys) still go out in a single write.
+        //
+        // The submit key, when present, is the TAIL of `data` (callers pass
+        // `body + sendKey` for the atomic-submit paths). Because we chunk the
+        // combined string, the submit key always rides in the SAME final write as
+        // the body's tail — the win32 invariant that ConPTY recognizes it as a
+        // submit — and is never emitted before the whole body has been written
+        // (no partial-body submit). Body-only writes (wait_for_echo strategy) have
+        // their submit key sent separately by the caller afterwards, unchanged.
+        if (process.platform === 'win32' && shouldChunkWin32Write(data.length)) {
+            await this.writeWin32Chunked(data);
+            return;
+        }
         await this.ptyProcess.write(data);
     }
 
+    /** Write `data` to the PTY in bounded, surrogate-safe chunks with a short
+     *  inter-chunk gap (win32 paced write). Awaits each chunk's write and the gap
+     *  so the returned promise resolves only after the FINAL chunk (carrying any
+     *  trailing submit key) has been written. */
+    private async writeWin32Chunked(data: string): Promise<void> {
+        const chunks = chunkPreservingSurrogates(data, WIN32_PTY_WRITE_CHUNK_CHARS);
+        for (let i = 0; i < chunks.length; i += 1) {
+            if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+            await this.ptyProcess.write(chunks[i]);
+            if (i + 1 < chunks.length) {
+                await new Promise<void>(resolve => setTimeout(resolve, WIN32_PTY_WRITE_CHUNK_GAP_MS));
+            }
+        }
+    }
+
     private resetPendingSendState(reason: string): void {
         this.responseBuffer = '';
         if (this.responseTimeout) { clearTimeout(this.responseTimeout); this.responseTimeout = null; }
@@ -1472,7 +1516,24 @@ export class ProviderCliAdapter implements CliAdapter {
                 LOG.info('CLI', `[${this.cliType}] sendMessage recovered idle prompt readiness`);
             }
         }
-        if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.engine.currentStatus})`);
+        if (!this.ready) {
+            // Readiness barrier (queue-until-ready). A task dispatched the instant a
+            // freshly-spawned session is launched can arrive BEFORE the PTY prints its
+            // interactive prompt (this.ready flips ~2-6s later). Previously this threw
+            // "not ready" and the delegated-task delivery promise requeued the task,
+            // which on win32 raced the auto-launch cooldown and could strand the worker
+            // idle with no work (the "first big message lost" failure). Instead, when the
+            // caller allows queueing, BUFFER the message in the pending-outbound queue and
+            // return — the startup-settle path flips this.ready and flushes the queue once
+            // the prompt is actually up (see resolveStartupState → flushPendingOutboundQueue),
+            // so the message is delivered late rather than dropped. A non-queueable caller
+            // (e.g. an internal flush) still throws so it isn't silently swallowed.
+            if (allowQueue) {
+                this.enqueuePendingOutboundMessage(text, 'not_ready_pending_prompt');
+                return;
+            }
+            throw new Error(`${this.cliName} not ready (status: ${this.engine.currentStatus})`);
+        }
         const parsedSessionStatus = typeof parsedStatusBeforeSend?.status === 'string'
             ? String(parsedStatusBeforeSend.status)
             : '';

package/src/cli-adapters/pty-write-chunking.ts

@@ -0,0 +1,106 @@
+/**
+ * Shared win32 ConPTY paced-write chunking.
+ *
+ * A single unbounded ConPTY `write()` can overflow the console input pipe and
+ * drop LEADING bytes once the payload exceeds ~1KB — the "long task message gets
+ * truncated (head lost, tail kept)" failure. The fix is to split a large body
+ * into bounded chunks written with a short inter-chunk gap so the console input
+ * buffer keeps up. Small bodies still go out in a single write.
+ *
+ * This module is the SINGLE source of truth for the chunk size / gap / surrogate-
+ * safe split so the two write paths that need it — the spec FsmDriver
+ * (writeWin32Body) and the legacy ProviderCliAdapter (writeToPty / submit paths)
+ * — cannot drift apart and regress on one side (the original bug: "one branch
+ * patched, the other not").
+ */
+'use strict';
+
+// Defensive paced PTY write tuning. 1024 chars per chunk stays comfortably under
+// the ConPTY input-pipe threshold; an 8ms gap lets the console reader drain
+// between chunks without adding meaningful latency to a normal-sized prompt.
+export const WIN32_PTY_WRITE_CHUNK_CHARS = 1024;
+export const WIN32_PTY_WRITE_CHUNK_GAP_MS = 8;
+
+/** Split `text` into chunks of at most `size` UTF-16 units without ever cutting
+ *  between a high and low surrogate (which would corrupt an astral char — emoji,
+ *  etc. — on the UTF-8 PTY write). */
+export function chunkPreservingSurrogates(text: string, size: number): string[] {
+    const chunks: string[] = [];
+    let offset = 0;
+    while (offset < text.length) {
+        let end = Math.min(text.length, offset + size);
+        if (end < text.length) {
+            const code = text.charCodeAt(end - 1);
+            // Boundary lands on a high surrogate → pull back one so the pair stays
+            // together in the next chunk.
+            if (code >= 0xd800 && code <= 0xdbff) end -= 1;
+        }
+        if (end <= offset) end = Math.min(text.length, offset + size); // size 1 on a lone surrogate
+        chunks.push(text.slice(offset, end));
+        offset = end;
+    }
+    return chunks;
+}
+
+/** True when a body of `length` UTF-16 units should be paced into multiple
+ *  chunks on win32 rather than written in a single PTY write. */
+export function shouldChunkWin32Write(length: number): boolean {
+    return length > WIN32_PTY_WRITE_CHUNK_CHARS;
+}
+
+/**
+ * Drive a paced, surrogate-safe chunked write of `text` over a `write(chunk)`
+ * sink, calling `onChunkWritten` after each chunk (e.g. to advance an input-
+ * activity timestamp) and `onDone` once the final chunk is out. The optional
+ * `setTimer` lets the caller own the timer handle (so it can be cleared on
+ * shutdown) and supply a custom scheduler in tests; it defaults to setTimeout.
+ *
+ * Bodies at or below the chunk threshold are written in a SINGLE write — the
+ * common case — so this is a no-op pacing wrapper for normal-sized prompts.
+ *
+ * Returns the chunks that will be written (useful for assertions/logging).
+ */
+export interface PacedWin32WriteOptions {
+    write: (chunk: string) => void;
+    onChunkWritten?: () => void;
+    onDone?: () => void;
+    /** Schedule the next chunk; must return a handle the caller can clear.
+     *  Defaults to setTimeout. */
+    setTimer?: (fn: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    /** Store the pending timer handle so the caller can clear it on shutdown. */
+    onTimer?: (handle: ReturnType<typeof setTimeout> | null) => void;
+    chunkChars?: number;
+    gapMs?: number;
+}
+
+export function writeWin32Paced(text: string, opts: PacedWin32WriteOptions): string[] {
+    const chunkChars = opts.chunkChars ?? WIN32_PTY_WRITE_CHUNK_CHARS;
+    const gapMs = opts.gapMs ?? WIN32_PTY_WRITE_CHUNK_GAP_MS;
+    const setTimer = opts.setTimer ?? ((fn, delayMs) => setTimeout(fn, delayMs));
+
+    if (text.length <= chunkChars) {
+        opts.onTimer?.(null);
+        opts.write(text);
+        opts.onChunkWritten?.();
+        opts.onDone?.();
+        return [text];
+    }
+
+    const chunks = chunkPreservingSurrogates(text, chunkChars);
+    let idx = 0;
+    const writeNext = (): void => {
+        opts.onTimer?.(null);
+        if (idx >= chunks.length) { opts.onDone?.(); return; }
+        opts.write(chunks[idx]);
+        opts.onChunkWritten?.();
+        idx += 1;
+        if (idx < chunks.length) {
+            const handle = setTimer(writeNext, gapMs);
+            opts.onTimer?.(handle);
+        } else {
+            opts.onDone?.();
+        }
+    };
+    writeNext();
+    return chunks;
+}