sortie-dogs 0.2.14 → 0.2.15

package/README.md

@@ -146,7 +146,7 @@ Optional settings in `.opencode/sortie-dogs.json`:
   "handoffPaths": ["handoff.json"],
   "readOnlyTools": ["my_mcp_search"],
   "dedicatedWorkerModel": { "model": "provider/model", "variant": "deep" },
-  "continuation": { "enabled": true, "maxAutoContinues": 3 },
+  "continuation": { "enabled": true, "maxAutoContinues": 2 },
   "reflection": {
     "enabled": false,
     "layers": { "run": true, "project": true, "global": false }
@@ -180,9 +180,9 @@ global file for durable global settings.
   and resumes the same root session on the next independent unit. Only a root
   `dog-coordinator` session is ever resumed: a child session is never promoted and
   another coordinator is never adopted. Set `enabled` to `false` to keep every
-  batch manual, raise or lower `maxAutoContinues` (default `3`, maximum `10`) to
-  change the ceiling, and set `summarizeModel` to pin the compaction model when
-  the host default is unsuitable. Normal OpenCode auto-compaction keeps the
+  batch manual, raise or lower `maxAutoContinues` (default `2`, maximum `10`) to
+  change the ceiling, and set `summarizeModel` to override the latest coordinator
+  model used for compaction. Normal OpenCode auto-compaction keeps the
   host's auto-continue behavior; Sortie suppresses it only while its own
   explicitly queued rollover owns the resume.
 - `reflection` is an opt-in process-prevention companion for an activated root

package/dist/plugin/config.d.ts

@@ -44,7 +44,7 @@ export interface ContinuationConfiguration {
     readonly agent: string;
     readonly capability: string;
     readonly maxAutoContinues: number;
-    /** Absent means the host picks the compaction model; this package never pins one. */
+    /** Absent reuses the latest coordinator model observed for this session. */
     readonly summarizeModel?: ModelTarget;
 }
 export interface ConsultationPolicyInput {

package/dist/plugin/continuation.d.ts

@@ -22,7 +22,7 @@ export declare const ROLLOVER_MARKER = "<!-- SORTIE_COMPACT -->";
 export declare const AUTO_CONTINUE_PREFIX = "SORTIE_AUTO_CONTINUE";
 /** First line the rollover summary must emit, mirroring the batch target of three attempts. */
 export declare const ROLLOVER_TOKEN = "SORTIE_ROLLOVER_COMPACTED";
-export declare const DEFAULT_MAX_AUTO_CONTINUES = 3;
+export declare const DEFAULT_MAX_AUTO_CONTINUES = 2;
 /**
  * A coordinator that exhausted its step budget reports remaining work instead of continuing. That
  * report is a continuation request in every respect except the marker, so it is treated as one.
@@ -34,12 +34,12 @@ declare const DEFAULT_TIMINGS: {
     readonly cooldownMilliseconds: 60000;
     /** Let the new summary's token state settle before a fresh turn can trigger overflow compaction. */
     readonly settleMilliseconds: 1500;
-    /** A rollover that cannot start yet is retried on a short backoff rather than dropped. */
-    readonly scheduleMilliseconds: 1500;
+    /** Session idle starts rollover normally; this delayed path only recovers a missing idle event. */
+    readonly scheduleMilliseconds: 30000;
     readonly scheduleAttempts: 2;
 };
 export type ContinuationTimings = typeof DEFAULT_TIMINGS;
-export type ContinuationRejection = "identity-unavailable" | "child-session" | "agent-mismatch" | "capability-unavailable" | "continuation-disabled" | "limit-reached" | "pending-autocontinue";
+export type ContinuationRejection = "identity-unavailable" | "child-session" | "agent-mismatch" | "capability-unavailable" | "continuation-disabled" | "limit-reached" | "pending-autocontinue" | "summarize-model-unavailable";
 export interface ContinuationIdentity {
     readonly agent?: string | undefined;
     readonly parentID?: string | undefined;
@@ -82,7 +82,7 @@ export interface ContinuationClient {
             query?: {
                 directory?: string;
             };
-            body?: {
+            body: {
                 providerID: string;
                 modelID: string;
             };
@@ -125,7 +125,7 @@ export type ContinuationPolicySource = ContinuationPolicy | (() => ContinuationP
  * without an agent field, or answers for a different directory, instead of failing silently.
  */
 export type LocalIdentitySource = (sessionID: string) => ContinuationIdentity | undefined;
-export type RolloverAbort = "identity-unavailable" | "child-session" | "summarize-unavailable" | "retries-exhausted" | "terminal-identity-rejected";
+export type RolloverAbort = "identity-unavailable" | "child-session" | "summarize-unavailable" | "summarize-model-unavailable" | "retries-exhausted" | "terminal-identity-rejected";
 export interface ContinuationToolContext {
     readonly sessionID: string;
     readonly agent?: string | undefined;
@@ -154,6 +154,11 @@ export interface ContinuationHooks {
     }, output: {
         enabled: boolean;
     }): Promise<void>;
+    observeModel(sessionID: string, model: {
+        providerID: string;
+        modelID: string;
+    }): void;
+    blocksTool(sessionID: string): boolean;
     sessionIdle(sessionID: string): Promise<void>;
     forgetSession(sessionID: string): void;
 }

package/dist/plugin/continuation.js

@@ -22,7 +22,7 @@ export const ROLLOVER_MARKER = "<!-- SORTIE_COMPACT -->";
 export const AUTO_CONTINUE_PREFIX = "SORTIE_AUTO_CONTINUE";
 /** First line the rollover summary must emit, mirroring the batch target of three attempts. */
 export const ROLLOVER_TOKEN = "SORTIE_ROLLOVER_COMPACTED";
-export const DEFAULT_MAX_AUTO_CONTINUES = 3;
+export const DEFAULT_MAX_AUTO_CONTINUES = 2;
 /**
  * A coordinator that exhausted its step budget reports remaining work instead of continuing. That
  * report is a continuation request in every respect except the marker, so it is treated as one.
@@ -35,8 +35,8 @@ const DEFAULT_TIMINGS = {
     cooldownMilliseconds: 60_000,
     /** Let the new summary's token state settle before a fresh turn can trigger overflow compaction. */
     settleMilliseconds: 1_500,
-    /** A rollover that cannot start yet is retried on a short backoff rather than dropped. */
-    scheduleMilliseconds: 1_500,
+    /** Session idle starts rollover normally; this delayed path only recovers a missing idle event. */
+    scheduleMilliseconds: 30_000,
     scheduleAttempts: 2,
 };
 function nonEmpty(value) {
@@ -184,6 +184,7 @@ export function createContinuationHooks(client, directory, policySource, timings
             attempts: 0,
             pendingRollover: false,
             active: false,
+            compactedRollover: false,
             promptPending: false,
             directUsed: false,
             touched: Date.now(),
@@ -212,11 +213,30 @@ export function createContinuationHooks(client, directory, policySource, timings
             return undefined;
         }
     }
-    function summarizeBody() {
+    function summarizeBody(state) {
         const summarizeModel = policy().summarizeModel;
-        if (summarizeModel === undefined)
-            return undefined;
-        return openCodeModel(summarizeModel.model);
+        return summarizeModel === undefined ? state.model : openCodeModel(summarizeModel.model);
+    }
+    function summarizeCallSucceeded(response) {
+        if (response === true)
+            return true;
+        if (response === null || typeof response !== "object" || !("data" in response))
+            return false;
+        return response.data === true;
+    }
+    function promptCallSucceeded(response) {
+        if (response === undefined || response === true)
+            return true;
+        if (response === null || typeof response !== "object")
+            return false;
+        const result = response;
+        if (result.error !== undefined)
+            return false;
+        if (result.response?.ok === false)
+            return false;
+        if (typeof result.response?.status === "number" && result.response.status >= 400)
+            return false;
+        return true;
     }
     async function runRollover(sessionID) {
         const state = sessions.get(sessionID);
@@ -227,52 +247,65 @@ export function createContinuationHooks(client, directory, policySource, timings
             warnRollover(sessionID, "summarize-unavailable");
             return false;
         }
-        const cooldownRemaining = state.lastRollover === undefined
-            ? 0
-            : timings.cooldownMilliseconds - (Date.now() - state.lastRollover);
-        if (cooldownRemaining > 0) {
-            if (state.cooldownTimer === undefined) {
-                state.cooldownTimer = unrefTimer(setTimeout(() => {
-                    const current = sessions.get(sessionID);
-                    if (current !== undefined)
-                        current.cooldownTimer = undefined;
-                    void runRollover(sessionID);
-                }, cooldownRemaining));
-            }
-            return false;
-        }
-        // A child session must never compact or resume its parent's batch.
-        const identity = await readIdentity(sessionID);
-        if (identity === undefined || !nonEmpty(identity.agent)) {
-            warnRollover(sessionID, "identity-unavailable");
-            return false;
-        }
-        if (nonEmpty(identity.parentID)) {
-            warnRollover(sessionID, "child-session");
-            return false;
-        }
-        const continueReport = state.continueReport;
+        // Acquire the session lock before the first await so idle and fallback timers cannot overlap.
         state.active = true;
-        state.promptPending = true;
-        let summarized = false;
+        let compactionStarted = false;
+        let compactionSucceeded = false;
         try {
-            const body = summarizeBody();
-            await summarize.call(client.session, {
-                path: { id: sessionID },
-                query: { directory },
-                ...(body === undefined ? {} : { body }),
-            });
-            summarized = true;
-            state.lastRollover = Date.now();
-            state.pendingRollover = false;
-            state.continueReport = undefined;
-            if (continueReport === undefined)
+            const cooldownRemaining = state.lastRollover === undefined || state.compactedRollover
+                ? 0
+                : timings.cooldownMilliseconds - (Date.now() - state.lastRollover);
+            if (cooldownRemaining > 0) {
+                if (state.cooldownTimer === undefined) {
+                    state.cooldownTimer = unrefTimer(setTimeout(() => {
+                        const current = sessions.get(sessionID);
+                        if (current !== undefined)
+                            current.cooldownTimer = undefined;
+                        void runRollover(sessionID);
+                    }, cooldownRemaining));
+                }
+                return false;
+            }
+            // A child session must never compact or resume its parent's batch.
+            const identity = await readIdentity(sessionID);
+            if (identity === undefined || !nonEmpty(identity.agent)) {
+                warnRollover(sessionID, "identity-unavailable");
+                return false;
+            }
+            if (nonEmpty(identity.parentID)) {
+                warnRollover(sessionID, "child-session");
+                return false;
+            }
+            if (!state.compactedRollover) {
+                const body = summarizeBody(state);
+                if (body === undefined) {
+                    warnRollover(sessionID, "summarize-model-unavailable");
+                    return false;
+                }
+                state.promptPending = true;
+                compactionStarted = true;
+                const summarizedResponse = await summarize.call(client.session, {
+                    path: { id: sessionID },
+                    query: { directory },
+                    body,
+                });
+                if (!summarizeCallSucceeded(summarizedResponse))
+                    throw new Error("summarize request rejected");
+                state.compactedRollover = true;
+                compactionSucceeded = true;
+                state.lastRollover = Date.now();
+            }
+            const continueReport = state.continueReport;
+            if (continueReport === undefined) {
+                state.pendingRollover = false;
+                state.compactedRollover = false;
                 return true;
+            }
             const resume = client?.session?.promptAsync;
             if (resume === undefined)
-                return true;
-            await new Promise((settle) => unrefTimer(setTimeout(settle, timings.settleMilliseconds)));
-            await resume.call(client.session, {
+                throw new Error("resume capability unavailable");
+            await new Promise((settle) => setTimeout(settle, timings.settleMilliseconds));
+            const resumed = await resume.call(client.session, {
                 path: { id: sessionID },
                 query: { directory },
                 body: {
@@ -285,6 +318,11 @@ export function createContinuationHooks(client, directory, policySource, timings
                         }],
                 },
             });
+            if (!promptCallSucceeded(resumed))
+                throw new Error("resume request rejected");
+            state.pendingRollover = false;
+            state.compactedRollover = false;
+            state.continueReport = undefined;
             return true;
         }
         catch (error) {
@@ -295,7 +333,7 @@ export function createContinuationHooks(client, directory, policySource, timings
             const current = sessions.get(sessionID);
             if (current !== undefined) {
                 current.active = false;
-                if (!summarized)
+                if (compactionStarted && !compactionSucceeded)
                     current.promptPending = false;
             }
         }
@@ -311,6 +349,7 @@ export function createContinuationHooks(client, directory, policySource, timings
             }
             else if (!completed && state?.pendingRollover === true) {
                 state.pendingRollover = false;
+                state.compactedRollover = false;
                 state.promptPending = false;
                 state.continueReport = undefined;
                 warnRollover(sessionID, "retries-exhausted");
@@ -320,6 +359,7 @@ export function createContinuationHooks(client, directory, policySource, timings
     function queueRollover(sessionID, report, resume) {
         const state = stateFor(sessionID);
         state.pendingRollover = true;
+        state.compactedRollover = false;
         state.latestReport = report;
         state.continueReport = resume ? report : undefined;
         if (resume)
@@ -378,6 +418,12 @@ export function createContinuationHooks(client, directory, policySource, timings
             });
             if (!resolution.compact)
                 return `SORTIE_CONTINUATION_REJECTED: ${resolution.reason}`;
+            if (client?.session?.summarize === undefined) {
+                return "SORTIE_CONTINUATION_REJECTED: capability-unavailable";
+            }
+            if (summarizeBody(state) === undefined) {
+                return "SORTIE_CONTINUATION_REJECTED: summarize-model-unavailable";
+            }
             // The direct capability and the marker fallback are mutually exclusive within one turn.
             state.directUsed = true;
             queueRollover(context.sessionID, "Tool-requested Sortie rollover. Preserve task identity, both manifests, validation history, " +
@@ -457,6 +503,15 @@ export function createContinuationHooks(client, directory, policySource, timings
             if (pending)
                 output.enabled = false;
         },
+        observeModel(sessionID, model) {
+            if (!nonEmpty(model.providerID) || !nonEmpty(model.modelID))
+                return;
+            stateFor(sessionID).model = { providerID: model.providerID, modelID: model.modelID };
+        },
+        blocksTool(sessionID) {
+            const state = sessions.get(sessionID);
+            return state?.pendingRollover === true || state?.active === true || state?.promptPending === true;
+        },
         async sessionIdle(sessionID) {
             await runRollover(sessionID);
         },

package/dist/plugin/index.js

@@ -1374,6 +1374,8 @@ export const SortieDogsPlugin = async (input, options) => {
              */
             await ensureLoaded();
             await loaded?.modelRoutingHook?.(chatInput, output);
+            if (coordinatorOrigin)
+                continuation.observeModel(chatInput.sessionID, output.message.model);
         },
         ...(reflectionStartup ? { "experimental.chat.system.transform": async (transformInput, transformOutput) => {
                 if (!(await beginReflection(transformInput.sessionID)))
@@ -1433,8 +1435,12 @@ export const SortieDogsPlugin = async (input, options) => {
             await inspectSuccessfulRead(toolInput);
         },
         "tool.execute.before": async (toolInput, output) => {
-            if (isCoordinatorSession(toolInput.sessionID))
+            if (isCoordinatorSession(toolInput.sessionID)) {
+                if (continuation.blocksTool(toolInput.sessionID)) {
+                    throw new Error("SORTIE_ROLLOVER_PENDING: stop this turn and wait for compaction");
+                }
                 return;
+            }
             const status = activeSessionStatus(toolInput.sessionID);
             if (status === "inactive")
                 return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "description": "Bounded, validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",