clay-server 4.2.0 → 4.3.0-beta.1

package/lib/project-driver-continuation.js

@@ -0,0 +1,499 @@
+var crypto = require("crypto");
+var buildShape = require("./session-spawn-mcp-server").buildShape;
+var sessionProvenance = require("./session-provenance");
+var workspaceSessionRef = require("./workspace-query-service").sessionRef;
+var workerProposalControl = require("./worker-proposal-control");
+var transaction = require("./driver-continuation-transaction");
+var continuationAccess = require("./driver-continuation-access");
+var continuationLease = require("./driver-continuation-lease");
+var continuationStartup = require("./driver-continuation-startup");
+var continuationTrigger = require("./driver-continuation-trigger");
+var continuationPair = require("./driver-continuation-pair");
+var attachContinuationPairTransfer = require("./driver-continuation-pair-transfer").attachContinuationPairTransfer;
+var continuationRecord = require("./driver-continuation-record");
+var contextKey = continuationRecord.contextKey, findProposal = continuationRecord.findProposal,
+  hasEntries = continuationRecord.hasEntries, text = continuationRecord.text, toolResult = continuationRecord.toolResult;
+var MAX_FIELD_CHARS = 2400;
+var MAX_TOTAL_CHARS = 14000;
+var ACTIVE_RUN_STATES = ["armed", "running", "reviewing", "waiting-worker", "waiting-user", "paused"];
+var HANDOFF_FIELDS = ["goal", "constraints", "decisions", "rejectedApproaches", "unresolved", "nextAction", "verification", "repositoryState"];
+function attachDriverContinuation(ctx) {
+  var sm = ctx.sm;
+  function isLiveDriver(session) {
+    return continuationAccess.isLiveDriver(session, ctx.isMate, sm.sessions, ctx.isDriverOperatedSession);
+  }
+
+  function skipPermissions(session) {
+    return !!(ctx.dangerouslySkipPermissions || session && (
+      session.dangerouslySkipPermissions || session.permissionMode === "bypassPermissions" ||
+      session.effectivePermissionMode === "bypassPermissions"
+    ));
+  }
+  function authorize(session, ownerId) {
+    if (!isLiveDriver(session) || (session.ownerId || null) !== (ownerId || null)) return false;
+    try { return ctx.authorizeSession(session, ownerId) === true; }
+    catch (e) { return false; }
+  }
+  function update(session, proposal, patch) {
+    var applied = transaction.persist([{ target: proposal, patch: Object.assign({}, patch, { updatedAt: Date.now() }) }], function () {
+      return sm.saveSessionFile(session);
+    });
+    if (!applied.ok) return false;
+    sm.sendToSession(session, Object.assign({
+      type: "driver_continuation_update",
+      proposalId: proposal.proposalId,
+      sourceSessionId: session.localId,
+      sourceOriginId: proposal.sourceOriginId,
+      projectSlug: ctx.projectSlug,
+    }, patch));
+    return true;
+  }
+
+  function updateTarget(target, patch) {
+    return transaction.persist([{ target: target.driverContinuation, patch: patch }], function () {
+      return sm.saveSessionFile(target);
+    }).ok;
+  }
+
+  function normalizedHandoff(args) {
+    var handoff = {};
+    var total = 0;
+    for (var i = 0; i < HANDOFF_FIELDS.length; i++) {
+      var field = HANDOFF_FIELDS[i];
+      handoff[field] = text(args[field], MAX_FIELD_CHARS);
+      total += handoff[field].length;
+    }
+    if (!handoff.goal || !handoff.nextAction) return { error: "goal and nextAction are required." };
+    if (total > MAX_TOTAL_CHARS) return { error: "The continuation handoff is too long." };
+    return { value: handoff };
+  }
+
+  function proposalReason(args) {
+    return text(args && args.reason, 800);
+  }
+
+  function propose(args, session, generation) {
+    if (!authorize(session, session && session.ownerId || null)) return toolResult({ error: "Driver continuation requires an authorized live Project Driver session." });
+    if (skipPermissions(session)) return toolResult({ error: "Driver continuation proposals are disabled while Skip permissions is selected or forced." });
+    if (Number.isInteger(generation) && Number(session._sdkQueryGeneration || 0) !== generation) {
+      return toolResult({ error: "This continuation tool belongs to an older query." });
+    }
+    var reason = proposalReason(args);
+    var milestone = text(args && args.milestone, 1200);
+    var benefit = text(args && args.benefit, 1200);
+    var normalized = normalizedHandoff(args || {});
+    if (normalized.error) return toolResult({ error: normalized.error });
+    var eligibility = continuationTrigger.evaluate(session, ctx, {
+      reason: reason, milestone: milestone, benefit: benefit, nextAction: normalized.value.nextAction,
+    });
+    if (eligibility.error) return toolResult({ error: eligibility.error,
+      proposalId: eligibility.previous && eligibility.previous.proposalId || undefined });
+    var key = contextKey(session);
+    sessionProvenance.ensureOrigin(session);
+    var proposal = {
+      type: "driver_continuation_proposal",
+      proposalId: "continuation_" + crypto.randomUUID(),
+      status: "pending",
+      reason: reason,
+      milestone: milestone,
+      benefit: benefit,
+      handoff: normalized.value,
+      contextKey: key,
+      sourceSessionId: session.localId,
+      sourceOriginId: session.sessionOriginId,
+      sourceSessionRef: workspaceSessionRef(ctx.projectSlug, session),
+      ownerId: session.ownerId || null,
+      projectSlug: ctx.projectSlug,
+      contextStatus: eligibility.status,
+      triggerEvidence: eligibility.evidence,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+    var posted = transaction.appendPersisted(session, proposal, function () {
+      return sm.saveSessionFile(session);
+    });
+    if (!posted.ok) {
+      return toolResult({ error: "The continuation proposal could not be persisted. No review card was posted." });
+    }
+    sm.sendToSession(session, proposal);
+    return toolResult({
+      status: "posted",
+      proposalId: proposal.proposalId,
+      instruction: "The continuation card is waiting for the user's explicit choice. End this turn without accepting it yourself.",
+    });
+  }
+
+  function unsafeReason(session) {
+    if (session.isProcessing || session._queryStarting || session._awaitingTurnResult) return "Wait for the current Driver turn to finish, then retry.";
+    if (ctx.pendingMessageQueue && ctx.pendingMessageQueue.hasActive(session)) return "Pending human messages must be handled here before continuing in a new session.";
+    if (session.scheduledMessage || session.rateLimitAutoContinuePending) return "A scheduled callback is still attached to this session.";
+    if (session.autonomousRun && ACTIVE_RUN_STATES.indexOf(session.autonomousRun.state) !== -1) return "Until complete is still active in this session.";
+    if (hasEntries(session.pendingPermissions) || hasEntries(session.pendingAskUser) ||
+        hasEntries(session.pendingElicitations) || hasEntries(session.pendingUserDialogs)) {
+      return "This session is waiting for a permission or user-input response.";
+    }
+    if (workerProposalControl.pendingProposal(session)) return "A Split Worker proposal is still waiting for a decision.";
+    var pair = continuationPair.inspect(session, ctx);
+    if (!pair.ok) return pair.error;
+    if (!pair.group && (session._pairDelegation || continuationPair.activeFollowups(session))) {
+      return "Split Worker work or follow-ups are still pending.";
+    }
+    if (session.pendingPush && session.pendingPush.length) return "Messages are still waiting for delivery in this session.";
+    if (session.taskStopRequested || session.destroying || session._runtimeRefreshRequested) return "This session is changing state; retry when it is idle.";
+    return "";
+  }
+
+  function actorForResponse(ws, source) {
+    var userId = ws && ws._clayUser ? ws._clayUser.id : null;
+    if (ws._clayActiveSession !== source.localId) throw new Error("The continuation decision belongs to another source session.");
+    if (ctx.isMultiUser()) {
+      if (!userId || source.ownerId !== userId) throw new Error("Only the source Driver owner can decide this continuation.");
+    } else if (source.ownerId) {
+      throw new Error("The source Driver owner is unavailable.");
+    }
+    if (!authorize(source, userId)) throw new Error("Driver continuation access changed.");
+    return userId;
+  }
+
+  function successorFor(proposal) {
+    var found = null;
+    sm.sessions.forEach(function (candidate) {
+      if (found || !candidate || !candidate.driverContinuation) return;
+      if (candidate.driverContinuation.proposalId === proposal.proposalId &&
+          candidate.driverContinuation.sourceOriginId === proposal.sourceOriginId &&
+          candidate.driverContinuation.projectSlug === ctx.projectSlug &&
+          (candidate.ownerId || null) === proposal.ownerId) found = candidate;
+    });
+    return found;
+  }
+
+  function startupProven(candidate) {
+    var relation = candidate && candidate.driverContinuation;
+    return !!(candidate && candidate.cliSessionId && relation &&
+      relation.startupProof === "initialized" && Number.isInteger(relation.acceptedQueryGeneration));
+  }
+
+  function acceptanceError(ws, source, proposal) {
+    actorForResponse(ws, source);
+    if (skipPermissions(source)) return "Driver continuation is disabled while Skip permissions is selected or forced.";
+    if (proposal.contextKey !== contextKey(source)) return "The source work changed after this proposal. Ask the Driver to prepare a fresh continuation.";
+    return unsafeReason(source);
+  }
+
+  function releaseLease(source, lease) {
+    if (!continuationLease.end(source, lease)) return false;
+    if (typeof ctx.consumePendingMessage === "function") {
+      setImmediate(function () { ctx.consumePendingMessage(source); });
+    }
+    return true;
+  }
+
+  var pairTransferControl = attachContinuationPairTransfer({ ctx: ctx, update: update,
+    beginLease: continuationLease.begin, releaseLease: releaseLease });
+
+  function commitRelation(source, proposal, target) {
+    var relation = target.driverContinuation;
+    var transactionId = relation.transactionId || proposal.transactionId || "transition_" + crypto.randomUUID();
+    if (!startupProven(target)) {
+      return { ok: false, error: "The successor has no verified startup proof." };
+    }
+    if (relation.status === "starting") {
+      if (!updateTarget(target, { status: "prepared", transactionId: transactionId, preparedAt: Date.now() })) {
+        return { ok: false, error: "The prepared successor relationship could not be persisted." };
+      }
+    }
+    if (proposal.status !== "accepted" && proposal.transactionId !== transactionId) {
+      if (!update(source, proposal, { status: "starting", transactionId: transactionId, targetSessionId: target.localId,
+        targetOriginId: target.sessionOriginId, error: null })) {
+        return { ok: false, error: "The source continuation relationship could not be persisted." };
+      }
+    }
+    if (relation.status !== "accepted") {
+      if (!updateTarget(target, { status: "accepted", transactionId: transactionId, acceptedAt: Date.now() })) {
+        return { ok: false, error: "The accepted successor relationship could not be persisted." };
+      }
+    }
+    if (proposal.status !== "accepted") {
+      if (!update(source, proposal, { status: "accepted", transactionId: transactionId, targetSessionId: target.localId,
+        targetOriginId: target.sessionOriginId, acceptedAt: Date.now(), error: null })) {
+        return { ok: false, error: "The accepted source relationship could not be persisted." };
+      }
+    }
+    if (!transaction.accepted(proposal, relation)) return { ok: false, error: "The continuation relationship is not durably complete." };
+    return { ok: true };
+  }
+
+  async function accept(ws, source, proposal) {
+    var ownerId = actorForResponse(ws, source);
+    var reason = acceptanceError(ws, source, proposal);
+    if (reason) {
+      if (proposal.contextKey !== contextKey(source)) {
+        update(source, proposal, { status: "superseded", error: reason });
+      }
+      throw new Error(reason);
+    }
+    var existing = successorFor(proposal);
+    if (existing) {
+      if (!authorize(existing, ownerId)) throw new Error("Successor continuation access changed.");
+      if (!startupProven(existing)) {
+        if (!existing.queryInstance && !existing.isProcessing && !existing._queryStarting) {
+          sm.deleteSessionQuiet(existing.localId);
+          update(source, proposal, { status: "superseded", targetSessionId: null, targetOriginId: null,
+            error: "The prior successor did not survive startup. Prepare a fresh continuation proposal." });
+          throw new Error("The prior successor did not survive startup. Prepare a fresh continuation proposal.");
+        }
+        throw new Error("The successor is still starting. Wait for initialization confirmation before retrying.");
+      }
+      var retainedLease = source._driverContinuationLease;
+      if (!retainedLease) {
+        var recoveredPair = pairTransferControl.recoverIfNeeded(source, existing, proposal);
+        if (!recoveredPair.ok) throw new Error(recoveredPair.error);
+        retainedLease = recoveredPair.lease;
+      }
+      if (retainedLease && retainedLease.proposalId === proposal.proposalId && retainedLease.target === existing) {
+        var retryReason = pairTransferControl.retryError(source, existing, retainedLease, function () {
+          return acceptanceError(ws, source, proposal);
+        });
+        if (retryReason) throw new Error(retryReason);
+        var existingPairCommit = pairTransferControl.commitOrCancel(retainedLease);
+        if (!existingPairCommit.ok) throw new Error(existingPairCommit.error);
+      }
+      var existingCommit = commitRelation(source, proposal, existing);
+      if (!existingCommit.ok) throw new Error(existingCommit.error);
+      if (retainedLease && retainedLease.proposalId === proposal.proposalId && retainedLease.target === existing) {
+        releaseLease(source, retainedLease);
+      }
+      sm.switchSession(existing.localId, ws);
+      return { ok: true, status: "accepted", targetSessionId: existing.localId };
+    }
+    if (proposal.status === "starting") {
+      if (!update(source, proposal, { status: "pending", error: "The prior startup did not leave a durable successor. Retry when ready." })) {
+        throw new Error("The stale startup state could not be persisted.");
+      }
+    }
+    if (proposal.status !== "pending") throw new Error("This continuation proposal has already been resolved.");
+    var target = sm.createSessionRaw({
+      ownerId: source.ownerId || null,
+      sessionVisibility: source.sessionVisibility,
+      vendor: source.vendor,
+      model: source.model,
+      effort: source.effort,
+      permissionMode: source.permissionMode || null,
+    });
+    target.mcpPermissionModeOverrides = Object.assign({}, source.mcpPermissionModeOverrides || {});
+    target.effectivePermissionMode = null;
+    target.title = (source.title || "Continued work") + " · Continued";
+    target.driverContinuation = {
+      proposalId: proposal.proposalId,
+      sourceOriginId: proposal.sourceOriginId,
+      sourceSessionRef: proposal.sourceSessionRef,
+      projectSlug: ctx.projectSlug,
+      status: "starting",
+      createdAt: Date.now(),
+    };
+    sm.sendAndRecord(target, {
+      type: "driver_continuation_context",
+      proposalId: proposal.proposalId,
+      sourceSessionId: source.localId,
+      sourceOriginId: proposal.sourceOriginId,
+      sourceSessionRef: proposal.sourceSessionRef,
+      projectSlug: ctx.projectSlug,
+      reason: proposal.reason,
+      goal: proposal.handoff.goal,
+      nextAction: proposal.handoff.nextAction,
+      repositoryState: proposal.handoff.repositoryState,
+      _ts: Date.now(),
+    });
+    if (!update(source, proposal, { status: "starting", targetSessionId: target.localId, targetOriginId: target.sessionOriginId, error: null })) {
+      sm.deleteSessionQuiet(target.localId);
+      var persistenceError = "The source continuation proposal could not be persisted.";
+      update(source, proposal, { status: "pending", targetSessionId: null, targetOriginId: null, error: persistenceError });
+      throw new Error(persistenceError);
+    }
+    target.isProcessing = true;
+    target.sentToolResults = {};
+    ctx.onProcessingChanged();
+    var lease = continuationLease.begin(source, target, proposal.proposalId);
+    var pairTransfer = pairTransferControl.begin(source, target, proposal, lease);
+    if (!pairTransfer.ok) {
+      releaseLease(source, lease);
+      sm.deleteSessionQuiet(target.localId);
+      update(source, proposal, { status: "pending", targetSessionId: null, targetOriginId: null, error: pairTransfer.error });
+      throw new Error(pairTransfer.error);
+    }
+    function startupAcceptanceError() {
+      return pairTransferControl.validationError(source, target, lease, function () {
+        return acceptanceError(ws, source, proposal);
+      });
+    }
+    var started = false;
+    var retainTarget = false;
+    var timedOut = false;
+    function lateStartup(lifecycle) {
+      continuationStartup.handleLate({ sm: sm, source: source, target: target, proposal: proposal, lease: lease,
+        validate: startupAcceptanceError,
+        commitPair: function () { return pairTransferControl.commit(lease); },
+        release: function () { releaseLease(source, lease); },
+        update: function (patch) { return update(source, proposal, patch); } }, lifecycle);
+    }
+    try {
+      var sdk = ctx.getSdk();
+      if (!sdk || typeof sdk.startQueryWithAcceptance !== "function") throw new Error("SDK bridge cannot confirm successor startup.");
+      var lifecycle = await sdk.startQueryWithAcceptance(target, continuationStartup.compactPrompt(proposal), undefined,
+        ctx.getLinuxUserForSession(target), function () {
+          return continuationLease.guard(lease, startupAcceptanceError);
+        }, lateStartup);
+      started = !!(lifecycle && lifecycle.accepted === true);
+      retainTarget = !!(lifecycle && lifecycle.initialAccepted === true && lifecycle.queryAlive === true);
+      timedOut = !!(lifecycle && lifecycle.timedOut === true);
+      if (!started) throw new Error(lease.error || lifecycle && lifecycle.reason || "The successor agent did not accept the compact handoff.");
+      if (!Number.isInteger(lifecycle.queryGeneration)) throw new Error("The successor has no verified startup proof.");
+      target.driverContinuation.acceptedQueryGeneration = lifecycle.queryGeneration;
+      target.driverContinuation.acceptedInitialAt = Date.now();
+      target.driverContinuation.startupProof = "initialized";
+      if (!await continuationStartup.waitForDurableIdentity(sm, target, ctx.identityWaitMs)) throw new Error("The successor accepted its handoff but did not receive a durable session identity in time.");
+      if (!transaction.saveObserved(function () { return sm.saveSessionFile(target); })) {
+        lease.waitingCommit = true;
+        throw new Error("The verified successor startup could not be persisted. Retry without starting another successor.");
+      }
+      try { reason = startupAcceptanceError(); }
+      catch (revalidationError) { reason = revalidationError.message || String(revalidationError); }
+      if (reason) {
+        lease.cancel(reason);
+        throw new Error(reason);
+      }
+      lease.waitingCommit = true;
+      var pairCommitted = pairTransferControl.commit(lease);
+      if (!pairCommitted.ok) {
+        lease.cancel(pairCommitted.error);
+        throw new Error(pairCommitted.error);
+      }
+      var committed = commitRelation(source, proposal, target);
+      if (!committed.ok) throw new Error(committed.error);
+      releaseLease(source, lease);
+      sm.broadcastSessionList();
+      sm.switchSession(target.localId, ws);
+      return { ok: true, status: "accepted", targetSessionId: target.localId, ownerId: ownerId };
+    } catch (error) {
+      if (timedOut && retainTarget && !lease.cancelled) lease.waitingLateStartup = true;
+      else if (!lease.waitingCommit && !lease.cancelled) {
+        pairTransferControl.rollback(lease);
+        releaseLease(source, lease);
+      }
+      if (lease.cancelled && !lease.cleanupComplete) {
+        error = new Error(lease.cleanupError || error.message || String(error));
+      } else if (!lease.cleanupComplete && started !== true && retainTarget !== true) {
+        pairTransferControl.rollback(lease);
+        sm.deleteSessionQuiet(target.localId);
+      }
+      if (proposal.status !== "accepted") update(source, proposal, {
+        status: lease.cancelled ? "superseded" : "pending", targetSessionId: sm.sessions.has(target.localId) ? target.localId : null,
+        targetOriginId: sm.sessions.has(target.localId) ? target.sessionOriginId : null,
+        error: error.message || String(error),
+      });
+      throw error;
+    }
+  }
+  async function respond(ws, msg) {
+    var ownerId = ws && ws._clayUser ? ws._clayUser.id : null;
+    var source = continuationAccess.findOwnedSessionByOrigin(sm.sessions, msg.sourceOriginId, ownerId);
+    if (!source) throw new Error("The source Driver session no longer exists.");
+    actorForResponse(ws, source);
+    var proposal = findProposal(source, msg.proposalId);
+    if (!proposal || proposal.ownerId !== (source.ownerId || null) || proposal.projectSlug !== ctx.projectSlug ||
+        proposal.sourceOriginId !== source.sessionOriginId || proposal.sourceOriginId !== msg.sourceOriginId) {
+      throw new Error("The exact continuation proposal was not found.");
+    }
+    if (msg.accepted !== true) {
+      if (proposal.status !== "pending") throw new Error("This continuation proposal has already been resolved.");
+      var declinedAt = Date.now();
+      var declined = transaction.persist([
+        { target: source, patch: { driverContinuationDecline: { proposalId: proposal.proposalId, declinedAt: declinedAt, permanent: true } } },
+        { target: proposal, patch: { status: "declined", declinedAt: declinedAt, error: null, updatedAt: declinedAt } },
+      ], function () { return sm.saveSessionFile(source); });
+      if (!declined.ok) throw new Error("The decision to stay could not be persisted.");
+      sm.sendToSession(source, { type: "driver_continuation_update", proposalId: proposal.proposalId,
+        sourceSessionId: source.localId, sourceOriginId: proposal.sourceOriginId, projectSlug: ctx.projectSlug,
+        status: "declined", declinedAt: declinedAt, error: null });
+      return { ok: true, status: "declined", sourceSessionId: source.localId };
+    }
+    var result = await accept(ws, source, proposal);
+    result.sourceSessionId = source.localId;
+    return result;
+  }
+
+  function openSource(ws, msg) {
+    var target = sm.sessions.get(ws._clayActiveSession);
+    var relation = target && target.driverContinuation;
+    var ownerId = ws && ws._clayUser ? ws._clayUser.id : null;
+    if (!target || !relation || relation.proposalId !== msg.proposalId || relation.sourceOriginId !== msg.sourceOriginId) {
+      throw new Error("The exact continuation source link is stale.");
+    }
+    if (!authorize(target, ownerId)) throw new Error("Continuation source access changed.");
+    var source = null;
+    sm.sessions.forEach(function (candidate) {
+      if (source || !candidate) return;
+      if (candidate.sessionOriginId === relation.sourceOriginId && (candidate.ownerId || null) === (target.ownerId || null)) source = candidate;
+    });
+    if (!source || !authorize(source, ownerId)) throw new Error("The original Driver session is no longer available.");
+    sm.switchSession(source.localId, ws);
+    return { ok: true, status: "source_opened", targetSessionId: source.localId };
+  }
+
+  function handleMessage(ws, msg) {
+    if (msg.type !== "driver_continuation_response" && msg.type !== "driver_continuation_open_source") return false;
+    var requestId = text(msg.requestId, 128);
+    var exactProject = text(msg.projectSlug, 200);
+    var sourceOriginId = text(msg.sourceOriginId, 200);
+    var operationName = msg.type === "driver_continuation_open_source" ? "open_source" : "decision";
+    if (!requestId || exactProject !== ctx.projectSlug || !sourceOriginId) {
+      ctx.sendTo(ws, { type: "driver_continuation_result", requestId: requestId, operation: operationName,
+        projectSlug: ctx.projectSlug, sourceOriginId: sourceOriginId, proposalId: msg.proposalId,
+        sourceSessionId: null, ok: false, error: "The continuation request correlation is incomplete or stale." });
+      return true;
+    }
+    var operation = msg.type === "driver_continuation_open_source"
+      ? Promise.resolve().then(function () { return openSource(ws, msg); })
+      : respond(ws, msg);
+    operation.then(function (result) {
+      ctx.sendTo(ws, Object.assign({ type: "driver_continuation_result", requestId: requestId, operation: operationName,
+        projectSlug: ctx.projectSlug, sourceOriginId: sourceOriginId, proposalId: msg.proposalId,
+        sourceSessionId: null }, result));
+    }).catch(function (error) {
+      ctx.sendTo(ws, { type: "driver_continuation_result", requestId: requestId, operation: operationName,
+        projectSlug: ctx.projectSlug, sourceOriginId: sourceOriginId, proposalId: msg.proposalId,
+        sourceSessionId: null, ok: false, error: error.message || String(error) });
+    });
+    return true;
+  }
+
+  function getToolDefs(session, generation) {
+    if (!authorize(session, session && session.ownerId || null) || skipPermissions(session)) return [];
+    if (continuationTrigger.historicalProposal(session) || session.driverContinuationDecline) return [];
+    return [{
+      name: "propose_driver_continuation",
+      description: "Propose, but never accept, the source session's one user-reviewed proactive continuation. Clay requires measured current-context pressure or a completed recorded compaction, a completed milestone, a specific reason and benefit, and a prepared next action. Never claim guaranteed savings.",
+      inputSchema: buildShape({
+        reason: { type: "string", description: "Why moving at this specific boundary is useful now." },
+        milestone: { type: "string", description: "The concrete milestone completed before this safe transition boundary." },
+        benefit: { type: "string", description: "The concrete continuity benefit, without unsupported savings claims." },
+        goal: { type: "string" }, constraints: { type: "string" },
+        decisions: { type: "string", description: "Decisions and why they were made." },
+        rejectedApproaches: { type: "string" }, unresolved: { type: "string" },
+        nextAction: { type: "string" }, verification: { type: "string" }, repositoryState: { type: "string" },
+      }, ["reason", "milestone", "benefit", "goal", "nextAction"]),
+      handler: function (args) { return propose(args || {}, session, generation); },
+    }];
+  }
+
+  function getSystemPrompt(session) {
+    if (!authorize(session, session && session.ownerId || null) || skipPermissions(session)) return "";
+    if (continuationTrigger.historicalProposal(session) || session.driverContinuationDecline) return "";
+    return continuationTrigger.prompt(session) + " Never propose while a Split Worker is attached or work or user input is pending. " +
+      "After posting, end the turn. Same-project bounded history can be retrieved later; do not request global source reading.";
+  }
+
+  return { getSystemPrompt: getSystemPrompt, getToolDefs: getToolDefs, handleMessage: handleMessage, respond: respond, openSource: openSource };
+}
+
+module.exports = { attachDriverContinuation: attachDriverContinuation, contextKey: contextKey, findProposal: findProposal };