sortie-dogs 0.12.3 → 0.12.4

package/README.md

@@ -42,8 +42,8 @@ npm install --save-dev sortie-dogs
 npx sortie-dogs init .
 ```
 
-The package retains the `v010` profile/namespace for compatibility. Add the OpenCode V2 plugin and the required
-two-level subagent depth to `.opencode/opencode.json`, preserving existing values:
+The package retains the `v010` profile/namespace for compatibility. `init` adds the OpenCode V2 plugin and the required
+two-level subagent depth to `.opencode/opencode.json(c)`, preserving existing settings:
 
 ```json
 {
@@ -62,8 +62,8 @@ Selecting `dog-operator` directly starts the same workflow. `dog-operator` is th
 only user-facing v0.10 authority. `dogs-coordinator` and every `*-v010` role are
 internal children and must not be selected as task entry points.
 
-`init` installs runtime assets; the `plugins` entry loads runtime enforcement and
-model routing. Both are required. A new session alone does not reload an updated
+`init` installs runtime assets and merges the required OpenCode settings; the `plugins` entry loads runtime enforcement and
+model routing. A new session alone does not reload an updated
 plugin process, so restart OpenCode after installation or upgrade.
 
 ## v0.12.0 workflow
@@ -262,9 +262,8 @@ npm install --global sortie-dogs
 sortie-dogs init --global --profile v010
 ```
 
-Then add `sortie-dogs` and `experimental.subagent_depth: 2` to the global OpenCode config.
-Global initialization installs assets only; it does not silently change the
-default agent or merge user settings.
+Global initialization also merges `sortie-dogs` and `experimental.subagent_depth: 2` into the
+global OpenCode config, preserving unrelated settings and the default agent.
 
 ## Updates and removal
 

package/dist/core/initialize.js

@@ -11,6 +11,7 @@ import { constants } from "node:fs";
 import { lstat, mkdir, open, readFile, realpath, rm, rmdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { applyEdits, modify, parse } from "jsonc-parser";
 import { RUNTIME_PROFILES } from "./runtime-profile.js";
 const assets = await import(__rewriteRelativeImportExtension(`../runtime-assets.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
 const { runtimeAssets } = assets;
@@ -348,6 +349,46 @@ function layoutLegacyPath(asset, layout) {
         ? asset.relativePath.slice(`${OPEN_CODE_DIRECTORY}/`.length)
         : asset.relativePath;
 }
+async function v010Config(root, global) {
+    const prefix = global ? "" : `${OPEN_CODE_DIRECTORY}/`;
+    const json = `${prefix}opencode.json`, jsonc = `${prefix}opencode.jsonc`;
+    const presentJSON = await assertSafeExistingPath(root, json, true);
+    const presentJSONC = await assertSafeExistingPath(root, jsonc, true);
+    if (presentJSON && presentJSONC)
+        throw new ProjectInitializationError("conflict", "Both OpenCode JSON and JSONC configs exist; choose one before initialization.");
+    const relativePath = presentJSONC ? jsonc : json;
+    const previous = presentJSONC || presentJSON ? await readFile(resolve(root, relativePath)) : undefined;
+    let content = previous?.toString("utf8") ?? "{}\n";
+    const errors = [];
+    const config = parse(content, errors, { allowTrailingComma: true });
+    if (errors.length || config === null || typeof config !== "object" || Array.isArray(config)) {
+        throw new ProjectInitializationError("conflict", `OpenCode config ${relativePath} must be a valid JSON/JSONC object.`);
+    }
+    const current = config;
+    const plugins = current.plugins;
+    if (plugins !== undefined && (!Array.isArray(plugins) || !plugins.every(item => typeof item === "string" ||
+        (item !== null && typeof item === "object" && !Array.isArray(item) && typeof item.package === "string")))) {
+        throw new ProjectInitializationError("conflict", `OpenCode config ${relativePath} has an invalid plugins list.`);
+    }
+    if (current.experimental !== undefined && (current.experimental === null || typeof current.experimental !== "object" ||
+        Array.isArray(current.experimental)))
+        throw new ProjectInitializationError("conflict", `OpenCode config ${relativePath} has invalid experimental settings.`);
+    const depth = current.experimental?.subagent_depth;
+    if (depth !== undefined && (!Number.isSafeInteger(depth) || depth < 0)) {
+        throw new ProjectInitializationError("conflict", `OpenCode config ${relativePath} has an invalid subagent depth.`);
+    }
+    const options = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
+    const update = (path, value) => { content = applyEdits(content, modify(content, path, value, options)); };
+    if (!plugins?.some(item => item === "sortie-dogs" ||
+        (item !== null && typeof item === "object" && item.package === "sortie-dogs"))) {
+        update(["plugins"], [...(plugins ?? []), "sortie-dogs"]);
+    }
+    if (depth === undefined || depth < 2)
+        update(["experimental", "subagent_depth"], 2);
+    if (previous?.toString("utf8") === content)
+        return undefined;
+    return { entry: { relativePath, content }, previous };
+}
 async function initializeRoot(requestedRoot, layout, installAssets = runtimeAssets) {
     const root = resolve(requestedRoot);
     const legacyAssets = layout.legacyAssets ?? LEGACY_RUNTIME_ASSETS;
@@ -355,6 +396,7 @@ async function initializeRoot(requestedRoot, layout, installAssets = runtimeAsse
     if (rootInfo === undefined || !rootInfo.isDirectory() || rootInfo.isSymbolicLink()) {
         throw new ProjectInitializationError("invalid-project", layout.invalidRootMessage);
     }
+    const configUpdate = layout.configureV010 ? await v010Config(root, layout.assetPrefix === "") : undefined;
     const version = assetVersion(installAssets);
     const assetEntries = installAssets.map(({ installPath, content }) => ({
         relativePath: safeAssetPath(installPath, layout.assetPrefix),
@@ -381,7 +423,7 @@ async function initializeRoot(requestedRoot, layout, installAssets = runtimeAsse
     const markerText = existing[markerIndex];
     const matches = (entry, index) => existing[index]?.equals(Buffer.from(entry.content)) ?? false;
     const assetsMatch = assetEntries.every(matches);
-    if (markerText !== undefined && parseMarker(markerText.toString("utf8")) === version && assetsMatch) {
+    if (markerText !== undefined && parseMarker(markerText.toString("utf8")) === version && assetsMatch && !configUpdate) {
         if (layout.controlIgnore ?? !layout.preserveAllLegacy)
             await ensureProjectLunaControlIgnore(root);
         return {
@@ -449,6 +491,18 @@ async function initializeRoot(requestedRoot, layout, installAssets = runtimeAsse
                 });
             }
         }
+        if (configUpdate) {
+            const { entry, previous } = configUpdate;
+            const parent = dirname(entry.relativePath).replaceAll("\\", "/");
+            if (parent !== ".")
+                await ensureDirectory(root, parent, createdDirectories);
+            if (previous === undefined)
+                await createFile(resolve(root, entry.relativePath), entry.content, createdFiles);
+            else
+                await overwriteFileSafely(root, entry.relativePath, entry.content, () => {
+                    modifiedFiles.push({ relativePath: entry.relativePath, content: previous });
+                });
+        }
         for (const { asset } of removableLegacyFiles) {
             const state = await readableOwnedLegacyFile(root, asset);
             if (!Buffer.isBuffer(state)) {
@@ -478,7 +532,7 @@ async function initializeRoot(requestedRoot, layout, installAssets = runtimeAsse
     return {
         status: "installed",
         version,
-        installedPaths: entries.map(({ relativePath }) => relativePath),
+        installedPaths: [...entries.map(({ relativePath }) => relativePath), ...(configUpdate ? [configUpdate.entry.relativePath] : [])],
         preservedLegacyPaths,
     };
 }
@@ -502,7 +556,7 @@ export async function resolveGlobalConfigRoot(env = process.env, home = homedir(
         return resolve(env.XDG_CONFIG_HOME, "opencode");
     return resolve(home, ".config", "opencode");
 }
-/** Installs the packaged runtime into one existing project without changing user settings. */
+/** Installs the packaged runtime into one existing project, preserving unrelated user settings. */
 async function profileInstallation(id, global) {
     if (!Object.hasOwn(RUNTIME_PROFILES, id))
         throw new ProjectInitializationError("invalid-project", "Unknown runtime profile.");
@@ -515,7 +569,7 @@ async function profileInstallation(id, global) {
     return { layout: { ...(global ? GLOBAL_LAYOUT : PROJECT_LAYOUT),
             markerPath: global ? profile.markerFile : `${OPEN_CODE_DIRECTORY}/${profile.markerFile}`,
             preserveAllLegacy: false, controlIgnore: false, legacyAssets: V010_ROLE_NAME_LEGACY_ASSETS,
-            renamedTargets: ["agent/dog-operator.md", "agent/dogs-coordinator.md"] }, assets: module.runtimeAssets };
+            renamedTargets: ["agent/dog-operator.md", "agent/dogs-coordinator.md"], configureV010: true }, assets: module.runtimeAssets };
 }
 export async function initializeProject(projectRoot = process.cwd(), profile = "stable") {
     const install = await profileInstallation(profile, false);

package/dist/core/operator-mission.d.ts

@@ -60,6 +60,8 @@ export declare class OperatorMissionRuntime {
     update(root: string, change: (state: OperatorMission) => void): Promise<OperatorMission>;
     task(state: OperatorMission): OperatorTask;
     admit(root: string, callID: string, args: Record<string, unknown>): Promise<OperatorMission>;
+    /** Reopen only the exact dispatch whose native Task has a terminal record after a server restart. */
+    reconcileFinishedDispatch(root: string, missionID: string, callID: string): Promise<OperatorMission>;
     claim(root: string, child: string, prompt: string): Promise<string>;
     brief(state: OperatorMission): string;
 }

package/dist/core/operator-mission.js

@@ -144,6 +144,15 @@ export class OperatorMissionRuntime {
             state.submission = null;
         });
     }
+    /** Reopen only the exact dispatch whose native Task has a terminal record after a server restart. */
+    reconcileFinishedDispatch(root, missionID, callID) {
+        return this.update(root, state => {
+            if (state.id !== missionID || state.callID !== callID || !state.dispatchOpen ||
+                ["cancelled", "completed"].includes(state.phase))
+                throw new Error("mission-dispatch-reconciliation-stale");
+            state.dispatchOpen = false;
+        });
+    }
     async claim(root, child, prompt) {
         const state = await this.update(root, state => {
             if (state.phase !== "running" || !state.dispatchOpen || !state.callID ||

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { default } from "./plugin/v2.js";
 export { lintHandoff } from "./core/validate-semantics.js";
 export { validateWorktreeParallelContract } from "./core/validate-worktree-parallel.js";
 export { LUNA_FABRIC_CONTRACT_VERSION, admitLunaFabric, } from "./core/luna-fabric-contract.js";

package/dist/index.js

@@ -1,3 +1,5 @@
+// OpenCode V2 loads the package root named in `plugins`; keep the public named API intact.
+export { default } from "./plugin/v2.js";
 export { lintHandoff } from "./core/validate-semantics.js";
 export { validateWorktreeParallelContract } from "./core/validate-worktree-parallel.js";
 export { LUNA_FABRIC_CONTRACT_VERSION, admitLunaFabric, } from "./core/luna-fabric-contract.js";

package/dist/plugin/opencode.d.ts

@@ -1,14 +1,14 @@
 /**
- * Dedicated import entry point for OpenCode plugin wrappers.
+ * OpenCode V2's package loader resolves the `./plugin` export. Expose its
+ * default definition here as well as the named V1 factory used by wrappers.
  *
- * OpenCode configuration lists the package name in the `plugin` array:
- * `"plugin": ["sortie-dogs"]`. Files such as `.opencode/plugins/*.ts` use
+ * OpenCode configuration lists the package name in the `plugins` array:
+ * `"plugins": ["sortie-dogs"]`. V1 wrappers can still use
  * `import { SortieDogsPlugin } from "sortie-dogs/plugin"`.
  *
- * OpenCode treats every runtime export of a loaded plugin module as a plugin factory and calls
- * each one with the plugin input. A non-factory runtime export therefore fails the whole module
- * load and silently disables the plugin. This entry exposes the factory and nothing else; every
- * other runtime symbol stays on the package root.
+ * OpenCode V2 requires a default definition with an id and setup or effect function.
+ * Keep other runtime symbols on the package root rather than this shared entry.
  */
 export { SortieDogsV010Plugin as SortieDogsPlugin } from "./profiled.js";
+export { default } from "./v2.js";
 export type { OpenCodeEvent, OpenCodeHooks, OpenCodePlugin, OpenCodePluginInput, SortieDogsPluginOptions, } from "./index.js";

package/dist/plugin/opencode.js

@@ -1,13 +1,13 @@
 /**
- * Dedicated import entry point for OpenCode plugin wrappers.
+ * OpenCode V2's package loader resolves the `./plugin` export. Expose its
+ * default definition here as well as the named V1 factory used by wrappers.
  *
- * OpenCode configuration lists the package name in the `plugin` array:
- * `"plugin": ["sortie-dogs"]`. Files such as `.opencode/plugins/*.ts` use
+ * OpenCode configuration lists the package name in the `plugins` array:
+ * `"plugins": ["sortie-dogs"]`. V1 wrappers can still use
  * `import { SortieDogsPlugin } from "sortie-dogs/plugin"`.
  *
- * OpenCode treats every runtime export of a loaded plugin module as a plugin factory and calls
- * each one with the plugin input. A non-factory runtime export therefore fails the whole module
- * load and silently disables the plugin. This entry exposes the factory and nothing else; every
- * other runtime symbol stays on the package root.
+ * OpenCode V2 requires a default definition with an id and setup or effect function.
+ * Keep other runtime symbols on the package root rather than this shared entry.
  */
 export { SortieDogsV010Plugin as SortieDogsPlugin } from "./profiled.js";
+export { default } from "./v2.js";

package/dist/plugin/profiled.js

@@ -376,6 +376,35 @@ export function createProfiledPlugin(profile, assetVersion) {
                 throw new Error("mission-controller-required");
             return { root, mission };
         }
+        async function reconcileMissionDispatch(root) {
+            const mission = await missions.read(root);
+            if (!mission?.dispatchOpen || !mission.callID || ["cancelled", "completed"].includes(mission.phase) ||
+                taskOwners.has(mission.callID))
+                return mission;
+            const history = await messages(root);
+            const finished = history.flatMap(message => Array.isArray(message.parts) ? message.parts : []).filter(part => record(part) && part.type === "tool" && part.tool === "task" && part.callID === mission.callID &&
+                record(part.state) && ["completed", "error"].includes(String(part.state.status)) &&
+                record(part.state.input) && part.state.input.subagent_type === profileAgent(profile, "dog-operator") &&
+                (part.state.input.task_id === undefined || part.state.input.task_id === mission.coordinator) &&
+                (mission.coordinator !== null || (part.state.input.prompt === missions.task(mission).prompt &&
+                    part.state.input.task_id === undefined)));
+            if (finished.length !== 1)
+                return mission;
+            if (mission.coordinator !== null) {
+                const who = await identity(mission.coordinator);
+                if (who.parent !== root || who.role !== "dog-operator")
+                    return mission;
+            }
+            return missions.reconcileFinishedDispatch(root, mission.id, mission.callID);
+        }
+        function missionDispatchPacket(mission, run) {
+            const packet = missionPacket(mission, run);
+            if (!mission.dispatchOpen && ["open", "running"].includes(mission.phase)) {
+                return { ...packet, task: missions.task(mission),
+                    next_action: "The previous Coordinator Task is finished. Dispatch this exact Task to continue the same mission and Coordinator session; keep the original requirements and cumulative budget." };
+            }
+            return packet;
+        }
         async function restorePriorAcceptance(root, state) {
             const succeeded = [...state.units].reverse().find(unit => unit.status === "succeeded");
             const current = succeeded === undefined ? undefined : {
@@ -608,12 +637,17 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const root = await rootFor(context.sessionID);
                 if (!root)
                     throw new Error("operator-grant-invalid");
+                const activeMission = await reconcileMissionDispatch(root);
+                if (activeMission && context.sessionID === root && !activeMission.dispatchOpen &&
+                    ["open", "running"].includes(activeMission.phase)) {
+                    return JSON.stringify({ ...missionDispatchPacket(activeMission, await operators.read(root)), budget: await control.currentBudget(root) });
+                }
                 const result = await operators.next(root, context.sessionID);
                 const mission = await missions.read(root);
                 if (mission && !["cancelled", "completed"].includes(mission.phase)) {
                     if (record(result) && record(result.task))
                         return JSON.stringify(result);
-                    return JSON.stringify({ ...missionPacket(mission, await operators.required(root)), budget: await control.currentBudget(root) });
+                    return JSON.stringify({ ...missionDispatchPacket(mission, await operators.required(root)), budget: await control.currentBudget(root) });
                 }
                 if (context.sessionID === root && record(result) && record(result.task)) {
                     const state = await operators.required(root);
@@ -652,9 +686,9 @@ export function createProfiledPlugin(profile, assetVersion) {
         tools[status] = { description: "Read the durable root-owned operator outcome and host budget counters (max_units, consumed_units, reserved_units, remaining_units) without claiming acceptance or retrying work. An investigating proposal returns its exact short Task reference only before a Task has been admitted; an existing admission never yields a redispatch Task.",
             args: {}, execute: async (_args, context) => {
                 const root = await rootFor(context.sessionID);
-                const mission = root ? await missions.read(root) : undefined;
+                const mission = root && context.sessionID === root ? await reconcileMissionDispatch(root) : root ? await missions.read(root) : undefined;
                 if (mission && (context.sessionID === root || context.sessionID === mission.coordinator)) {
-                    return JSON.stringify({ ...missionPacket(mission, await operators.read(root)), budget: await control.currentBudget(root) });
+                    return JSON.stringify({ ...missionDispatchPacket(mission, await operators.read(root)), budget: await control.currentBudget(root) });
                 }
                 await requireRoot(context.sessionID);
                 const state = await operators.read(context.sessionID);
@@ -1083,9 +1117,12 @@ export function createProfiledPlugin(profile, assetVersion) {
         tools[startMission] = { description: "Operator: save a few one-line requirements/negative constraints. The original user message, IDs and ownership are captured automatically. Dispatch the returned Coordinator task immediately, or use plan_units for a simple single-unit Fast-lane task.",
             args: { requirements: { ...stringList, minItems: 1, maxItems: 64 } }, execute: async (args, context) => {
                 await requireRoot(context.sessionID);
+                await reconcileMissionDispatch(context.sessionID);
                 const mission = await missions.start(context.sessionID, args.requirements);
-                return JSON.stringify({ mission_id: mission.id, requirements: mission.requirements, task: missions.task(mission),
-                    next_action: "Nontrivial: dispatch task now. Simple single-unit work with known scope/check: call plan_units directly. Do not create a proposal or ask for plan approval." });
+                return JSON.stringify(mission.dispatchOpen
+                    ? missionDispatchPacket(mission, await operators.read(context.sessionID))
+                    : { mission_id: mission.id, requirements: mission.requirements, task: missions.task(mission),
+                        next_action: "Nontrivial: dispatch task now. Simple single-unit work with known scope/check: call plan_units directly. Do not create a proposal or ask for plan approval." });
             } };
         async function declareMissionUnits(root, actor, mission, raw, reason) {
             const plan = missionPlan(mission, raw);
@@ -1498,6 +1535,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (request.tool === "task" && args.subagent_type === profileAgent(profile, "dog-operator") &&
                     mission && !["completed", "cancelled"].includes(mission.phase)) {
                     await requireRoot(request.sessionID);
+                    await reconcileMissionDispatch(root);
                     await missions.admit(root, request.callID, args);
                     taskOwners.set(request.callID, { root, actor: request.sessionID, operator: false, mission: true });
                     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.12.3",
+  "version": "0.12.4",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",
@@ -72,7 +72,8 @@
   },
   "dependencies": {
     "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1"
+    "ajv-formats": "^3.0.1",
+    "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",