sortie-dogs 0.2.13 → 0.2.15

package/README.md

@@ -144,11 +144,22 @@ Optional settings in `.opencode/sortie-dogs.json`:
 {
   "operationManifestPath": "operation-manifest.json",
   "handoffPaths": ["handoff.json"],
-  "readOnlyTools": ["my_mcp_search"],
-  "dedicatedWorkerModel": { "model": "provider/model", "variant": "deep" },
-  "continuation": { "enabled": true, "maxAutoContinues": 3 }
-}
-```
+  "readOnlyTools": ["my_mcp_search"],
+  "dedicatedWorkerModel": { "model": "provider/model", "variant": "deep" },
+  "continuation": { "enabled": true, "maxAutoContinues": 2 },
+  "reflection": {
+    "enabled": false,
+    "layers": { "run": true, "project": true, "global": false }
+  }
+}
+```
+
+The same schema may be saved globally as
+`~/.config/opencode/sortie-dogs.json` (on Windows,
+`%USERPROFILE%\.config\opencode\sortie-dogs.json`). Precedence is built-in
+defaults, global file, project file, `SORTIE_DOGS_CONFIG`, then plugin factory
+options. OpenCode plugin normalization may omit factory options, so use the
+global file for durable global settings.
 
 - `operationManifestPath` moves the manifest; the path is project-relative.
 - `handoffPaths` lists the handoff files the plugin inspects. A worker can only
@@ -169,9 +180,16 @@ Optional settings in `.opencode/sortie-dogs.json`:
   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.
+  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
+  `dog-coordinator`. It is disabled by default. Run and project layers default
+  to enabled after opt-in; the cross-project global storage layer remains
+  disabled unless explicitly enabled. Child and non-coordinator sessions fail
+  closed, and `SORTIE_REFLECTION=0` is an immediate kill switch.
 
 ## Why Sortie-dogs
 

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 {
@@ -99,3 +99,4 @@ export declare const DEFAULT_PLUGIN_OPTIONS: Readonly<Omit<Required<SortieDogsPl
 export declare function resolvePluginConfiguration(...values: readonly unknown[]): PluginConfiguration;
 /** Resolve the plugin's fixed source boundaries: project-local first, environment and host global. */
 export declare function resolvePluginConfigurationSources(projectValue: unknown, environmentValue: unknown, hostValue: unknown): PluginConfigurationSources;
+export declare function resolvePluginConfigurationSourcesWithGlobal(globalValue: unknown, projectValue: unknown, environmentValue: unknown, hostValue: unknown): PluginConfigurationSources;

package/dist/plugin/config.js

@@ -372,17 +372,23 @@ export function resolvePluginConfiguration(...values) {
 }
 /** Resolve the plugin's fixed source boundaries: project-local first, environment and host global. */
 export function resolvePluginConfigurationSources(projectValue, environmentValue, hostValue) {
-    const configured = resolvePluginConfiguration(projectValue, environmentValue, hostValue);
+    return resolvePluginConfigurationSourcesWithGlobal(undefined, projectValue, environmentValue, hostValue);
+}
+export function resolvePluginConfigurationSourcesWithGlobal(globalValue, projectValue, environmentValue, hostValue) {
+    const configured = resolvePluginConfiguration(globalValue, projectValue, environmentValue, hostValue);
     if (configured.kind === "invalid")
         return configured;
+    const globalLayer = parseLayer(globalValue);
     const projectLayer = parseLayer(projectValue);
     const environmentLayer = parseLayer(environmentValue);
     const hostLayer = parseLayer(hostValue);
-    if (projectLayer === undefined || environmentLayer === undefined || hostLayer === undefined) {
+    if (globalLayer === undefined || projectLayer === undefined ||
+        environmentLayer === undefined || hostLayer === undefined) {
         return { kind: "invalid" };
     }
     const globalModelRouting = Object.fromEntries(Object.entries({
         ...recommendedRoleRouting(configured.dedicatedWorkerModel),
+        ...(globalLayer.modelRouting ?? {}),
         ...(environmentLayer.modelRouting ?? {}),
         ...(hostLayer.modelRouting ?? {}),
     }).filter(([role]) => !isFixedModelRole(role)));

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" | "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;
             }
         }
@@ -304,14 +342,24 @@ export function createContinuationHooks(client, directory, policySource, timings
         unrefTimer(setTimeout(async () => {
             const completed = await runRollover(sessionID);
             const state = sessions.get(sessionID);
+            if (!completed && (state?.cooldownTimer !== undefined || state?.active === true))
+                return;
             if (!completed && state?.pendingRollover === true && attempt < timings.scheduleAttempts) {
                 scheduleRollover(sessionID, attempt + 1);
             }
+            else if (!completed && state?.pendingRollover === true) {
+                state.pendingRollover = false;
+                state.compactedRollover = false;
+                state.promptPending = false;
+                state.continueReport = undefined;
+                warnRollover(sessionID, "retries-exhausted");
+            }
         }, timings.scheduleMilliseconds * (attempt + 1)));
     }
     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)
@@ -370,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, " +
@@ -446,9 +500,18 @@ export function createContinuationHooks(client, directory, policySource, timings
                     identity.agent !== policy().agent)
                     return;
             }
-            if (input.overflow !== true || pending)
+            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

@@ -5,7 +5,7 @@ import { RUNTIME_ASSET_VERSION } from "../asset-version.js";
 import { normalizeRelativePath, RelativePathError } from "../core/path.js";
 import { validateManifest } from "../core/validate-manifest.js";
 import { safeSchemaPointer, validateHandoffSchema, validateOperationManifestSchema, } from "../core/validate-schema.js";
-import { DEFAULT_PLUGIN_OPTIONS, resolvePluginConfigurationSources, } from "./config.js";
+import { DEFAULT_PLUGIN_OPTIONS, resolvePluginConfiguration, resolvePluginConfigurationSourcesWithGlobal, } from "./config.js";
 import { CONTINUATION_CAPABILITY, createContinuationHooks, } from "./continuation.js";
 import { WriteDeniedError, createProjectPaths, createWriteGate, describeUnclassifiedCommand, isKnownReadOnlyTool, normalizeCommand, resolveProjectRoot, safePath, } from "./gate.js";
 import { createModelRoutingHook, } from "./model-routing-hook.js";
@@ -190,6 +190,22 @@ async function readOptionalProjectConfig(project) {
         throw error;
     }
 }
+async function readOptionalGlobalConfig() {
+    try {
+        const value = await readJson(join(configRoot(), "sortie-dogs.json"), INPUT_LIMITS.config);
+        if (resolvePluginConfiguration(value).kind === "invalid") {
+            console.warn("[sortie-dogs] global configuration ignored: invalid or unavailable");
+            return undefined;
+        }
+        return value;
+    }
+    catch (error) {
+        if (isAbsentPathError(error))
+            return undefined;
+        console.warn("[sortie-dogs] global configuration ignored: invalid or unavailable");
+        return undefined;
+    }
+}
 function readEnvironmentConfig() {
     const source = process.env[ENV_CONFIG];
     if (source === undefined || source.length === 0)
@@ -411,11 +427,12 @@ export const SortieDogsPlugin = async (input, options) => {
     let loading;
     let manifestAbsent = false;
     let assetVersionReported = false;
+    const globalConfig = await readOptionalGlobalConfig();
     // Project config read is required discovery for its opt-in; no reflection storage/version read
     // occurs unless that resolved config enables reflection. It stays isolated from write-gate load.
     try {
         project = await createProjectPaths(resolveProjectRoot(input));
-        const probed = resolvePluginConfigurationSources(await readOptionalProjectConfig(project), readEnvironmentConfig(), options);
+        const probed = resolvePluginConfigurationSourcesWithGlobal(globalConfig, await readOptionalProjectConfig(project), readEnvironmentConfig(), options);
         if (probed.kind === "configured" && reflectionEnabled(probed.reflection)) {
             reflectionVersion = await nearestPackageVersion();
             reflectionConfiguration = probed.reflection;
@@ -463,7 +480,7 @@ export const SortieDogsPlugin = async (input, options) => {
                 await reportAssetVersionSkew(project);
                 const projectConfig = await readOptionalProjectConfig(project);
                 const environmentConfig = readEnvironmentConfig();
-                const parsed = resolvePluginConfigurationSources(projectConfig, environmentConfig, options);
+                const parsed = resolvePluginConfigurationSourcesWithGlobal(globalConfig, projectConfig, environmentConfig, options);
                 if (parsed.kind === "invalid")
                     throw new WriteDeniedError("manifest-unavailable", "<unknown>");
                 loaded = loadConfigured(parsed, input.worktree ?? project.root, input.client);
@@ -1357,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)))
@@ -1416,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.13",
+  "version": "0.2.15",
   "description": "Bounded, validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",