@zq-silk/yui 0.15.3 → 0.15.6

package/dist/runtime/tmuxAdapters.js

@@ -3,10 +3,10 @@ import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
 import { createRuntimeBinding } from "./runtimeBinding.js";
 import { normalizeRuntimeOwner } from "./runtimeOwner.js";
-import { RuntimeGenerationMismatchError, RuntimeHostContentionError } from "./ports.js";
+import { RuntimeGenerationMismatchError, RuntimeHostContentionError, RuntimeHostUnavailableError, promptPushOutcome } from "./ports.js";
+import { providerDeliveryFailureFrom } from "./agentError.js";
 import { toRuntimeLaunchFailure } from "./launchDiagnostics.js";
 import { requireSafeIdentity } from "./validation.js";
-import { YUI_CONTROL_PLANE_DESCRIPTOR } from "./exactControlPlane.js";
 import { launchBrokerForHome } from "./launchBroker.js";
 import { AGENT_HOST_CONTROL_PROTOCOL, sendAgentHostLaunchControl, sendAgentHostTurnControl, sendAgentHostSteerControl, waitForAgentHostLaunchAck } from "./agentHost.js";
 const DEFAULT_INACTIVITY_TIMEOUT_MS = 300_000;
@@ -307,11 +307,9 @@ export class TmuxSessionHost {
         }
         const broker = launchBrokerForHome(yuiHome);
         const sessionManifest = planned.launch.env.YUI_SESSION_MANIFEST;
-        const frozenControlPlane = planned.launch.env[YUI_CONTROL_PLANE_DESCRIPTOR];
         if (request.owner.scope === "task" && request.turnId !== undefined
-            && (sessionManifest === undefined
-                || frozenControlPlane === undefined)) {
-            throw new Error("Managed Task Agent Host launch is missing its Session Manifest or frozen control descriptor.");
+            && sessionManifest === undefined) {
+            throw new Error("Managed Task Agent Host launch is missing its Session Manifest.");
         }
         const reservation = broker.reserve(Object.freeze({
             schemaVersion: 2,
@@ -352,10 +350,7 @@ export class TmuxSessionHost {
                     : { YUI_WORKSPACE: planned.launch.env.YUI_WORKSPACE }),
                 ...(sessionManifest === undefined
                     ? {}
-                    : { YUI_SESSION_MANIFEST: sessionManifest }),
-                ...(frozenControlPlane === undefined
-                    ? {}
-                    : { [YUI_CONTROL_PLANE_DESCRIPTOR]: frozenControlPlane })
+                    : { YUI_SESSION_MANIFEST: sessionManifest })
             }
         };
         let hostCreated = false;
@@ -413,18 +408,28 @@ export class TmuxSessionHost {
                 if (controlResult.outcome === "active-same-generation") {
                     broker.revoke(request.runtimeGenerationId);
                 }
-                const acceptableState = ["idle", "ready", "busy"].includes(controlResult.snapshot.state);
-                if (!acceptableState
-                    || controlResult.snapshot.runtimeGenerationId !== reservation.runtimeGenerationId) {
+                // Identity and readiness are separate facts. Only a genuinely
+                // different generation is a conflict that must fail closed, not
+                // permission to stop the Host; a matching unsettled generation is this
+                // exact activation still coming up, and stopping it would destroy a
+                // healthy Session (and any Turn it is carrying).
+                const observedGeneration = controlResult.snapshot.runtimeGenerationId;
+                if (observedGeneration !== reservation.runtimeGenerationId) {
                     broker.revoke(request.runtimeGenerationId);
-                    try {
-                        await stopExactRole(this.tmux, hostId, request.owner.roleName);
-                    }
-                    catch {
-                        // The coordinator will enqueue durable owner cleanup.
+                    throw new RuntimeGenerationMismatchError(reservation.runtimeGenerationId, observedGeneration, controlResult.snapshot.state, `Agent Host acknowledgement generation mismatch for ${reservation.runtimeGenerationId}; observed=${observedGeneration ?? "none"}; `
+                        + `state=${controlResult.snapshot.state}${describeHostFailure(controlResult)}.`);
+                }
+                if (!["idle", "ready", "busy"].includes(controlResult.snapshot.state)) {
+                    broker.revoke(request.runtimeGenerationId);
+                    if (["starting", "settling", "delivery-unknown"].includes(controlResult.snapshot.state)) {
+                        // The right generation is present but not yet deliverable. This
+                        // is transient backpressure, so leave the Host running and let
+                        // the caller retry rather than terminalizing the Turn.
+                        throw new RuntimeHostContentionError("provider-child-active", `The Agent Host for ${request.owner.roleName} is still ${controlResult.snapshot.state} on this exact generation${describeHostFailure(controlResult)}.`);
                     }
-                    throw new RuntimeGenerationMismatchError(reservation.runtimeGenerationId, controlResult.snapshot.runtimeGenerationId, controlResult.snapshot.state, `Agent Host acknowledgement generation mismatch for ${reservation.runtimeGenerationId}; observed=${controlResult.snapshot.runtimeGenerationId ?? "none"}; `
-                        + `state=${controlResult.snapshot.state}.`);
+                    // This launch is unusable. It did not create this Host, so failure
+                    // is not authority to clean its resources or unknown execution.
+                    throw new RuntimeHostUnavailableError(reservation.runtimeGenerationId, controlResult.snapshot.state, `Agent Host reached ${controlResult.snapshot.state} for ${reservation.runtimeGenerationId}${describeHostFailure(controlResult)}.`, { cause: controlResult.failure ?? controlResult.snapshot });
                 }
                 providerSnapshot = controlResult.snapshot;
                 providerDispatchObserved = true;
@@ -551,6 +556,15 @@ async function deadHostLaunchFailure(tmux, hostId, roleName, pane, context) {
         ...(stderrTail === undefined || stderrTail.length === 0 ? {} : { stderrTail })
     });
 }
+/**
+ * Appends the Host's own cause to a launch diagnostic. Without this the
+ * caller only learns the state name and the real reason stays trapped in the
+ * Host process.
+ */
+function describeHostFailure(result) {
+    const detail = result.failure?.detail ?? result.snapshot.detail;
+    return detail === undefined ? "" : `; detail=${detail}`;
+}
 /** Structured managed-Turn input; tmux remains presentation/liveness only. */
 export class AgentHostPromptPushAdapter {
     home;
@@ -562,7 +576,7 @@ export class AgentHostPromptPushAdapter {
         if (ref.scope !== "task" || request.binding.nativeSessionId === undefined
             || request.binding.providerAuthority === undefined
             || request.binding.providerAuthority.owner !== "controller") {
-            return "unavailable";
+            return promptPushOutcome("unavailable");
         }
         try {
             const result = await sendAgentHostTurnControl({
@@ -583,28 +597,28 @@ export class AgentHostPromptPushAdapter {
                     }
                 }
             });
-            if (result.snapshot.state === "delivery-unknown")
-                return "delivery-unknown";
+            // The Host attaches its own structured cause to every non-delivery.
+            const failure = result.failure;
+            if (result.snapshot.state === "delivery-unknown") {
+                return promptPushOutcome("delivery-unknown", failure);
+            }
             if (result.snapshot.state === "busy")
-                return "busy";
+                return promptPushOutcome("busy", failure);
             if (result.outcome === "rejected")
-                return "rejected";
+                return promptPushOutcome("rejected", failure);
             if (result.snapshot.attemptId !== request.envelope.id) {
                 return result.snapshot.state === "starting" || result.snapshot.state === "settling"
-                    ? "busy"
-                    : "unavailable";
+                    ? promptPushOutcome("busy", failure)
+                    : promptPushOutcome("unavailable", failure);
             }
             if (result.snapshot.state === "ready")
-                return "delivered";
+                return promptPushOutcome("delivered");
             return result.snapshot.state === "starting" || result.snapshot.state === "settling"
-                ? "busy"
-                : "unavailable";
+                ? promptPushOutcome("busy", failure)
+                : promptPushOutcome("unavailable", failure);
         }
         catch (error) {
-            const code = error.code;
-            return code === "ENOENT" || code === "ECONNREFUSED"
-                ? "unavailable"
-                : "delivery-unknown";
+            return transportFailureOutcome(error, "turn-submit", request.envelope.id);
         }
     }
     async trySteer(request) {
@@ -628,21 +642,36 @@ export class AgentHostPromptPushAdapter {
                 }
             });
             if (result.outcome === "accepted")
-                return "delivered";
-            if (result.snapshot.state === "delivery-unknown")
-                return "delivery-unknown";
+                return promptPushOutcome("delivered");
+            const failure = result.failure;
+            if (result.snapshot.state === "delivery-unknown") {
+                return promptPushOutcome("delivery-unknown", failure);
+            }
             if (result.snapshot.state === "busy")
-                return "busy";
-            return result.outcome === "rejected" ? "rejected" : "unavailable";
+                return promptPushOutcome("busy", failure);
+            return result.outcome === "rejected"
+                ? promptPushOutcome("rejected", failure)
+                : promptPushOutcome("unavailable", failure);
         }
         catch (error) {
-            const code = error.code;
-            return code === "ENOENT" || code === "ECONNREFUSED"
-                ? "unavailable"
-                : "delivery-unknown";
+            return transportFailureOutcome(error, "turn-submit", request.envelope.id);
         }
     }
 }
+/**
+ * A transport failure decides the input disposition. A refused or absent
+ * socket proves the Host never received the request; anything else leaves
+ * delivery genuinely ambiguous and must not be replayed automatically.
+ */
+function transportFailureOutcome(error, phase, attemptId) {
+    const code = error.code;
+    const unreachable = code === "ENOENT" || code === "ECONNREFUSED";
+    return promptPushOutcome(unreachable ? "unavailable" : "delivery-unknown", providerDeliveryFailureFrom(error, {
+        phase,
+        attemptId,
+        inputDisposition: unreachable ? "not-accepted" : "unknown"
+    }));
+}
 async function ensureRoleWindow(tmux, hostId, role, launch) {
     return tmux.ensureRoleWindowAsync === undefined
         ? tmux.ensureRoleWindow(hostId, role, launch)

package/dist/scheduler/activeRoleTurnDelivery.js

@@ -2,9 +2,9 @@ import { serializeTurnInputEnvelope } from "../context/turnInputContract.js";
 import { roleSessionMayContinue, sameEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { RuntimeLifecycleBusyError } from "../runtime/lifecycleReservation.js";
 import { managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
-import { serializeAgentErrorRaw } from "../runtime/agentError.js";
+import { formatProviderDeliveryFailure, providerDeliveryFailureFacts, innermostCauseName, serializeAgentErrorRaw } from "../runtime/agentError.js";
 import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
-import { RuntimeLaunchError } from "../runtime/ports.js";
+import { RuntimeGenerationMismatchError, RuntimeLaunchError } from "../runtime/ports.js";
 import { formatTurnReceiptId } from "../task/taskRecordReference.js";
 import { turnInputEnvelope } from "../turn/turn.js";
 import { captureRoleTurnDispatch } from "../coordination/workMailboxQueue.js";
@@ -63,7 +63,10 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
     if (currentProviderTurn !== null) {
         const reason = currentProviderTurn.terminalReason
             ?? `Provider Turn ended with status ${currentProviderTurn.status} without recording its Turn result.`;
-        return failTurnDelivery(store, turn, now, "missing-result", reason);
+        // A terminal Provider projection without an application result is a
+        // framework consistency failure, not evidence that the Agent omitted its
+        // report. Keep the exact input fenced; never submit it again.
+        return { ...base, status: "skipped", reason: "delivery-uncertain", error: reason };
     }
     const attemptId = initialAttemptId;
     const mode = turn.mode;
@@ -117,29 +120,59 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
             receiptId: attemptId,
             text: serializeTurnInputEnvelope(turnInputEnvelope(turn))
         });
-        if (outcome === "busy" || outcome === "unavailable") {
+        if (outcome.status === "busy" || outcome.status === "unavailable") {
             forget(delivery, task.id, role.name, turn.id, ready.prepared.runtimeGenerationId);
             return {
                 ...base,
                 status: "skipped",
-                reason: outcome === "busy" ? "not-ready" : "runtime-unavailable"
+                reason: outcome.status === "busy" ? "not-ready" : "runtime-unavailable"
             };
         }
-        if (outcome === "rejected" || outcome === "delivery-unknown") {
+        if (outcome.status === "rejected" || outcome.status === "delivery-unknown") {
             forget(delivery, task.id, role.name, turn.id, ready.prepared.runtimeGenerationId);
-            return failTurnDelivery(store, turn, now, outcome === "delivery-unknown" ? "delivery-unknown" : "runtime-failed", outcome === "delivery-unknown"
-                ? "Provider Turn delivery is ambiguous; Yui will not replay it automatically."
-                : "Provider rejected the managed Turn.");
+            const unknown = outcome.status === "delivery-unknown";
+            const failure = outcome.failure;
+            // The Host's own account of the failure. Without it the only honest
+            // statement is that delivery did not complete — never that the Provider
+            // rejected the input, which is one specific cause among many.
+            const cause = failure === undefined
+                ? `The Agent Host did not deliver the managed Turn (${outcome.status}) and reported no cause.`
+                : formatProviderDeliveryFailure(failure);
+            // This path is the common Provider write failure and previously left no
+            // durable fact at all, so the cause was unrecoverable after the fact.
+            store.recordAgentError?.({
+                taskId: task.id,
+                roleName: role.name,
+                turnId: turn.id,
+                source: "host",
+                phase: failure?.phase ?? "turn-submit",
+                message: cause,
+                // The Host already serialized the complete redacted chain. Re-serializing
+                // the failure object here would persist this layer's wrapper instead of
+                // the original cause, which is the detail an authorized reader needs.
+                raw: failure?.raw ?? serializeAgentErrorRaw(failure ?? cause),
+                inputDisposition: failure?.inputDisposition ?? (unknown ? "unknown" : "not-accepted"),
+                ...providerDeliveryFailureFacts(failure)
+            }, now);
+            return failTurnDelivery(store, turn, now, unknown ? "delivery-unknown" : "runtime-failed", unknown
+                ? `Provider Turn delivery is ambiguous; Yui will not replay it automatically. ${cause}`
+                : cause);
         }
         forget(delivery, task.id, role.name, turn.id, ready.prepared.runtimeGenerationId);
         settleAcceptedRoleTurnDispatch(store, turn, dispatchToken);
         return {
             ...base,
-            status: outcome === "sent" ? "delivered" : "already-delivered"
+            status: outcome.status === "sent" ? "delivered" : "already-delivered"
         };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        // A launch failure carries its own structure — the class that threw, the
+        // innermost cause, and for a generation mismatch both generations. Recording
+        // only `message` flattened all of it into prose that no reader could
+        // reliably parse back.
+        const causeName = innermostCauseName(error);
+        const mismatch = error instanceof RuntimeGenerationMismatchError ? error : undefined;
         store.recordAgentError?.({
             taskId: task.id,
             roleName: role.name,
@@ -148,7 +181,22 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
             phase: submitted ? "turn-submit" : mode === "new" ? "session-start" : "session-restore",
             message,
             raw: serializeAgentErrorRaw(error),
-            inputDisposition: submitted ? "unknown" : "not-accepted"
+            inputDisposition: submitted ? "unknown" : "not-accepted",
+            // Nothing was submitted, so the Provider provably holds no registration
+            // for this attempt; after a submit the Host owns that fact, not this layer.
+            ...(submitted ? {} : { registrationDisposition: "not-committed" }),
+            ...(error instanceof Error ? { errorName: error.name } : {}),
+            ...(causeName === undefined ? {} : { causeName }),
+            ...(mismatch === undefined ? {} : {
+                expectedRuntimeGenerationId: mismatch.expectedRuntimeGenerationId,
+                ...(mismatch.observedRuntimeGenerationId === undefined
+                    ? {}
+                    : { observedRuntimeGenerationId: mismatch.observedRuntimeGenerationId })
+            }),
+            ...(error instanceof RuntimeLaunchError
+                ? { expectedRuntimeGenerationId: error.runtimeGenerationId }
+                : {}),
+            attemptId
         }, now);
         if (error instanceof RuntimeLifecycleBusyError
             || (error instanceof RuntimeLaunchError && error.retryable)) {

package/dist/scheduler/leaderWakeupProcessor.js

@@ -3,6 +3,7 @@ import { roleSessionMayContinue } from "../executor/effectiveLaunch.js";
 import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
 import { createTurn } from "../turn/turn.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
+import { formatProviderDeliveryFailure, providerDeliveryFailureFacts, serializeAgentErrorRaw, innermostCauseName } from "../runtime/agentError.js";
 export const LEADER_WAKE_AGGREGATION_MS = 60_000;
 export const LEADER_WAKE_FORCE_MS = 10 * 60_000;
 /**
@@ -146,6 +147,15 @@ async function forceLeaderSteer(store, delivery, taskId, roleName, active, now)
         }
     }
     const owner = `leader-steer:${active.id}`;
+    if (existing?.owner === owner) {
+        // A previous pass already claimed this input. If it could not settle the
+        // claim, delivery may have happened even when the Host has since restarted.
+        // Do not turn a mailbox read into an automatic Provider retry.
+        return {
+            taskId, turnId: active.id, status: "skipped", reason: "not-ready",
+            error: "The existing Leader steer attempt is unresolved; its mailbox claim and error evidence are preserved."
+        };
+    }
     const batchId = existing?.batchId
         ?? `leader-steer:${encodeURIComponent(taskId)}:${encodeURIComponent(active.id)}:${pending.fromSequence}-${pending.toSequence}`;
     const claim = store.claimWorkMailbox({ target, batchId, owner, now });
@@ -156,6 +166,11 @@ async function forceLeaderSteer(store, delivery, taskId, roleName, active, now)
     if (processing.batchId !== batchId || processing.owner !== owner) {
         return { taskId, turnId: active.id, status: "skipped", reason: "busy" };
     }
+    const receiptId = `turn-input:${taskId}/${active.id}/${batchId}`;
+    let inputMayBeAccepted = false;
+    let inputAccepted = false;
+    let deliveryReturned = false;
+    let runtimeGenerationId;
     try {
         const sessions = store.getTaskRoleSessionSet?.(taskId, roleName) ?? null;
         const session = sessions?.sessions[active.effective.agentId];
@@ -192,6 +207,8 @@ async function forceLeaderSteer(store, delivery, taskId, roleName, active, now)
             directive,
             deltaRefIds: []
         });
+        runtimeGenerationId = session.runtimeGenerationId;
+        inputMayBeAccepted = true;
         const outcome = await delivery.steerOnce({
             taskId,
             roleName,
@@ -205,18 +222,40 @@ async function forceLeaderSteer(store, delivery, taskId, roleName, active, now)
                 owner: "controller",
                 holderId: authority.holderId
             },
-            receiptId: `turn-input:${taskId}/${active.id}/${batchId}`,
+            receiptId,
             text: directive
         });
-        if (outcome !== "sent" && outcome !== "already-sent") {
-            if (outcome !== "delivery-unknown")
+        deliveryReturned = true;
+        inputAccepted = outcome.status === "sent" || outcome.status === "already-sent"
+            || outcome.failure?.inputDisposition === "accepted";
+        inputMayBeAccepted = outcome.status === "delivery-unknown" || inputAccepted;
+        if (outcome.status !== "sent" && outcome.status !== "already-sent") {
+            if (!inputMayBeAccepted)
                 store.releaseWorkMailbox(target, batchId);
+            const failure = outcome.failure;
+            if (failure !== undefined || outcome.status === "rejected" || outcome.status === "delivery-unknown") {
+                store.recordAgentError?.({
+                    taskId, roleName, turnId: active.id,
+                    source: "host",
+                    phase: failure?.phase ?? "turn-submit",
+                    message: failure === undefined ? `Leader steer ${outcome.status}.` : formatProviderDeliveryFailure(failure),
+                    raw: failure?.raw ?? serializeAgentErrorRaw(failure ?? outcome.status),
+                    inputDisposition: failure?.inputDisposition
+                        ?? (outcome.status === "delivery-unknown" ? "unknown" : "not-accepted"),
+                    ...providerDeliveryFailureFacts(failure),
+                    attemptId: receiptId
+                }, now);
+            }
             return {
                 taskId,
                 turnId: active.id,
-                status: outcome === "busy" ? "skipped" : "failed",
-                reason: outcome === "busy" ? "busy" : "not-ready",
-                error: outcome
+                status: outcome.status === "busy" ? "skipped" : "failed",
+                reason: outcome.status === "busy" ? "busy" : "not-ready",
+                // Report the Host's cause when it supplied one; the bare status word
+                // alone cannot distinguish a rejection from a lost transport.
+                error: outcome.failure === undefined
+                    ? outcome.status
+                    : `${outcome.status}: ${formatProviderDeliveryFailure(outcome.failure)}`
             };
         }
         const saved = store.saveLeaderSteer({ taskId, turnId: active.id, batchId, input, now });
@@ -227,7 +266,22 @@ async function forceLeaderSteer(store, delivery, taskId, roleName, active, now)
             : { taskId, turnId: active.id, status: "skipped", reason: saved };
     }
     catch (error) {
-        store.releaseWorkMailbox(target, batchId);
+        // A transport exception (or failure after delivery) is not evidence that
+        // the input was unsubmitted. Preserve its exact mailbox attempt.
+        if (!inputMayBeAccepted)
+            store.releaseWorkMailbox(target, batchId);
+        store.recordAgentError?.({
+            taskId, roleName, turnId: active.id,
+            source: inputMayBeAccepted && !deliveryReturned ? "host" : "yui",
+            phase: "turn-submit",
+            message: error instanceof Error ? error.message : String(error),
+            raw: serializeAgentErrorRaw(error),
+            inputDisposition: inputAccepted ? "accepted" : inputMayBeAccepted ? "unknown" : "not-accepted",
+            ...(error instanceof Error ? { errorName: error.name } : {}),
+            causeName: innermostCauseName(error),
+            expectedRuntimeGenerationId: runtimeGenerationId,
+            attemptId: receiptId
+        }, now);
         return {
             taskId,
             turnId: active.id,

package/dist/storage/sqliteSchema.js

@@ -688,6 +688,15 @@ CREATE UNIQUE INDEX idx_durable_jobs_request
 ON durable_jobs(task_id, json_extract(payload, '$.operation.actorId'),
   json_extract(payload, '$.operation.requestId'));
 `
+    },
+    {
+        version: 3,
+        name: "exact-attempt-result-identity",
+        introducedIn: "0.15.5",
+        // Append after the released T01 migration without changing its checksum.
+        // Accepted inputs/results can use an exact attempt without a native Turn id.
+        // Preserve all valid historical records; never repair failed Turns or logs.
+        sql: "SELECT 1; -- exact attempt identity without a fabricated native Turn id"
     }
 ]);
 for (let index = 0; index < MIGRATIONS.length; index += 1) {

package/dist/storage/storageVersions.js

@@ -13,4 +13,4 @@
  * intermediate Yui releases.
  */
 export const MIN_SUPPORTED_STORAGE_VERSION = 1;
-export const CURRENT_STORAGE_VERSION = 2;
+export const CURRENT_STORAGE_VERSION = 3;

package/dist/turn/turn.js

@@ -354,7 +354,13 @@ function validateTurnProviderResult(provider) {
     requireText(provider.accountScope, "Provider account scope");
     requireText(provider.conversationId, "Provider Conversation id");
     requireText(provider.activationId, "Provider Activation id");
-    requireText(provider.nativeTurnId, "Provider native Turn id");
+    if (provider.nativeTurnId !== undefined)
+        requireText(provider.nativeTurnId, "Provider native Turn id");
+    if (provider.attemptId !== undefined)
+        requireText(provider.attemptId, "Provider attempt id");
+    if (provider.nativeTurnId === undefined && provider.attemptId === undefined) {
+        throw new Error("Provider result requires a native Turn or exact attempt identity.");
+    }
     if (!["completed", "failed", "cancelled"].includes(provider.status)) {
         throw new Error(`Provider Turn result status is invalid: ${String(provider.status)}.`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.15.3",
+  "version": "0.15.6",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,