sortie-dogs 0.1.1

package/dist/plugin/index.js

@@ -0,0 +1,271 @@
+import { createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { RelativePathError } from "../core/path.js";
+import { validateManifest } from "../core/validate-manifest.js";
+import { validateHandoffSchema, validateOperationManifestSchema } from "../core/validate-schema.js";
+import { resolvePluginConfigurationSources, } from "./config.js";
+import { WriteDeniedError, createProjectPaths, createWriteGate, extractWritePaths, resolveProjectRoot, safePath, } from "./gate.js";
+import { createModelRoutingHook, } from "./model-routing-hook.js";
+const INPUT_LIMITS = { config: 64 * 1024, manifest: 512 * 1024, handoff: 2 * 1024 * 1024 };
+const INSPECTION_CACHE = { maximum: 256, ttlMilliseconds: 30 * 60 * 1000 };
+const PROJECT_CONFIG_PATH = ".opencode/sortie-dogs.json";
+const ENV_CONFIG = "SORTIE_DOGS_CONFIG";
+const COORDINATOR_AGENT = "dog-coordinator";
+const SORTIE_TRIGGER = /^\/sortie(?:\s|$)/;
+export class HandoffDeniedError extends Error {
+    reason;
+    constructor(reason, path, options) {
+        super(`Handoff denied for "${safePath(path)}": handoff and operation manifest contract.`, options);
+        this.name = "HandoffDeniedError";
+        this.reason = reason;
+    }
+}
+class PluginInputError extends Error {
+    reason;
+    constructor(reason, options) {
+        super("Plugin input unavailable.", options);
+        this.name = "PluginInputError";
+        this.reason = reason;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+async function readJson(path, limit) {
+    let metadata;
+    try {
+        metadata = await stat(path);
+    }
+    catch (error) {
+        throw new PluginInputError("read-failed", { cause: error });
+    }
+    if (!metadata.isFile())
+        throw new PluginInputError("not-file");
+    if (metadata.size > limit)
+        throw new PluginInputError("too-large");
+    let source;
+    try {
+        source = await readFile(path, "utf8");
+    }
+    catch (error) {
+        throw new PluginInputError("read-failed", { cause: error });
+    }
+    try {
+        return JSON.parse(source);
+    }
+    catch (error) {
+        throw new PluginInputError("invalid-json", { cause: error });
+    }
+}
+async function readOptionalProjectConfig(project) {
+    const path = project.absolute(PROJECT_CONFIG_PATH);
+    try {
+        return await readJson(path, INPUT_LIMITS.config);
+    }
+    catch (error) {
+        if (error instanceof PluginInputError &&
+            error.reason === "read-failed" &&
+            isRecord(error.cause) &&
+            error.cause.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+function readEnvironmentConfig() {
+    const source = process.env[ENV_CONFIG];
+    if (source === undefined || source.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(source);
+    }
+    catch (error) {
+        throw new PluginInputError("invalid-json", { cause: error });
+    }
+}
+async function loadConfigured(project, config) {
+    const manifestPath = await project.toRelativePath(config.operationManifestPath);
+    const manifestValue = await readJson(project.absolute(manifestPath), INPUT_LIMITS.manifest);
+    const validation = validateOperationManifestSchema(manifestValue);
+    if (!validation.ok)
+        throw new WriteDeniedError("manifest-unavailable", "<unknown>");
+    const gate = await createWriteGate(project, validation.value);
+    const handoffPaths = [];
+    for (const path of config.handoffPaths)
+        handoffPaths.push(await project.toRelativePath(path));
+    const hasModelRouting = Object.keys(config.localModelRouting).length > 0 ||
+        Object.keys(config.globalModelRouting).length > 0;
+    const modelRoutingHook = hasModelRouting
+        ? createModelRoutingHook({
+            local: config.localModelRouting,
+            global: config.globalModelRouting,
+            catalog: config.modelCatalog,
+        })
+        : undefined;
+    return { gate, manifest: validation.value, handoffPaths, modelRoutingHook };
+}
+function textPart(part) {
+    return isRecord(part) && typeof part.text === "string" ? part.text : undefined;
+}
+function activatesSession(input, output) {
+    if (input.agent === COORDINATOR_AGENT || output.message.agent === COORDINATOR_AGENT)
+        return true;
+    return output.parts.some((part) => {
+        const text = textPart(part);
+        return text !== undefined && SORTIE_TRIGGER.test(text);
+    });
+}
+function stableValue(value) {
+    if (Array.isArray(value))
+        return value.map(stableValue);
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stableValue(value[key])]));
+}
+function inspectionFingerprint(handoff, diagnostics) {
+    return createHash("sha256")
+        .update(JSON.stringify([stableValue(handoff), stableValue(diagnostics)]))
+        .digest("hex");
+}
+function pruneInspectionCache(cache, now) {
+    for (const [key, entry] of cache)
+        if (entry.expiresAt <= now)
+            cache.delete(key);
+    while (cache.size >= INSPECTION_CACHE.maximum)
+        cache.delete(cache.keys().next().value);
+}
+/** Named OpenCode plugin export. Importing the package has no side effects; invoking it installs active gates. */
+export const SortieDogsPlugin = async (input, options) => {
+    let project;
+    let loaded;
+    let loadFailure;
+    let loading;
+    async function ensureLoaded() {
+        if (loading !== undefined)
+            return loading;
+        loading = (async () => {
+            try {
+                project = await createProjectPaths(resolveProjectRoot(input));
+                const projectConfig = await readOptionalProjectConfig(project);
+                const environmentConfig = readEnvironmentConfig();
+                const parsed = resolvePluginConfigurationSources(projectConfig, environmentConfig, options);
+                if (parsed.kind === "invalid")
+                    throw new WriteDeniedError("manifest-unavailable", "<unknown>");
+                loaded = await loadConfigured(project, parsed);
+            }
+            catch (error) {
+                loadFailure = error;
+            }
+        })();
+        return loading;
+    }
+    const inspected = new Map();
+    const activeSessions = new Set();
+    async function inspect(path, sessionID) {
+        await ensureLoaded();
+        if (loaded === undefined || project === undefined) {
+            throw new HandoffDeniedError("configuration-unavailable", path, { cause: loadFailure });
+        }
+        let normalized;
+        try {
+            normalized = await project.toRelativePath(path);
+        }
+        catch (error) {
+            if (error instanceof WriteDeniedError || error instanceof RelativePathError) {
+                throw new HandoffDeniedError("path-invalid", path, { cause: error });
+            }
+            throw error;
+        }
+        if (!loaded.handoffPaths.includes(normalized))
+            return;
+        let value;
+        try {
+            value = await readJson(project.absolute(normalized), INPUT_LIMITS.handoff);
+        }
+        catch (error) {
+            if (error instanceof PluginInputError) {
+                throw new HandoffDeniedError("input-unavailable", normalized, { cause: error });
+            }
+            throw error;
+        }
+        const validation = validateHandoffSchema(value);
+        if (!validation.ok)
+            throw new HandoffDeniedError("schema-invalid", normalized);
+        const diagnostics = validateManifest(validation.value, loaded.manifest, undefined, false);
+        if (diagnostics.some(({ severity }) => severity === "error")) {
+            throw new HandoffDeniedError("contract-invalid", normalized);
+        }
+        const fingerprint = inspectionFingerprint(validation.value, diagnostics);
+        if (sessionID === undefined)
+            return;
+        const key = `${sessionID}\u0000${normalized}`;
+        const now = Date.now();
+        pruneInspectionCache(inspected, now);
+        if (inspected.get(key)?.fingerprint === fingerprint)
+            return;
+        inspected.delete(key);
+        inspected.set(key, { fingerprint, expiresAt: now + INSPECTION_CACHE.ttlMilliseconds });
+    }
+    return {
+        "chat.message": async (chatInput, output) => {
+            if (activatesSession(chatInput, output))
+                activeSessions.add(chatInput.sessionID);
+            if (!activeSessions.has(chatInput.sessionID))
+                return;
+            await ensureLoaded();
+            await loaded?.modelRoutingHook?.(chatInput, output);
+        },
+        "permission.ask": async (permission) => {
+            if (permission.permission !== "edit")
+                return;
+            if (permission.sessionID !== undefined && !activeSessions.has(permission.sessionID))
+                return;
+            await ensureLoaded();
+            if (loaded === undefined) {
+                throw new WriteDeniedError("manifest-unavailable", "<unknown>", { cause: loadFailure });
+            }
+            for (const pattern of permission.patterns) {
+                const path = isAbsolute(pattern) || input.worktree === undefined
+                    ? pattern
+                    : resolve(input.worktree, pattern);
+                await loaded.gate.checkPath(path);
+            }
+        },
+        "tool.execute.before": async (toolInput, output) => {
+            if (!activeSessions.has(toolInput.sessionID))
+                return;
+            await ensureLoaded();
+            if (loaded === undefined) {
+                const extraction = extractWritePaths(toolInput.tool, output.args);
+                if (extraction.applies) {
+                    throw new WriteDeniedError("manifest-unavailable", "<unknown>", { cause: loadFailure });
+                }
+                return;
+            }
+            await loaded.gate.check(toolInput, output);
+        },
+        event: async ({ event }) => {
+            const eventSessionID = typeof event.properties?.sessionID === "string"
+                ? event.properties.sessionID
+                : undefined;
+            if (eventSessionID === undefined || !activeSessions.has(eventSessionID))
+                return;
+            if (event.type === "file.edited" && typeof event.properties?.file === "string") {
+                await inspect(event.properties.file, eventSessionID);
+            }
+            else if (event.type === "session.idle" && eventSessionID !== undefined) {
+                await ensureLoaded();
+                if (loaded === undefined) {
+                    throw new HandoffDeniedError("configuration-unavailable", "<unknown>", { cause: loadFailure });
+                }
+                for (const path of loaded.handoffPaths)
+                    await inspect(path, eventSessionID);
+                activeSessions.delete(eventSessionID);
+            }
+            else if (event.type === "session.deleted") {
+                activeSessions.delete(eventSessionID);
+            }
+        },
+    };
+};
+export { InvalidModelTargetError, ModelRoutingDeniedError } from "./model-routing-hook.js";

package/dist/plugin/model-routing-hook.d.ts

@@ -0,0 +1,40 @@
+import { type ModelCatalog, type ModelResolutionAttempt, type ModelRoutingConfig } from "./model-routing.js";
+export interface OpenCodeChatMessageInput {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    messageID?: string;
+}
+export interface OpenCodeChatMessageOutput {
+    message: {
+        agent?: string;
+        model: {
+            providerID: string;
+            modelID: string;
+            variant?: string;
+        };
+        [key: string]: unknown;
+    };
+    parts: unknown[];
+}
+export type OpenCodeChatMessageHook = (input: OpenCodeChatMessageInput, output: OpenCodeChatMessageOutput) => Promise<void>;
+export interface ModelRoutingHookConfiguration {
+    readonly local?: ModelRoutingConfig;
+    readonly global?: ModelRoutingConfig;
+    readonly catalog: ModelCatalog;
+}
+export declare class ModelRoutingDeniedError extends Error {
+    readonly reason = "unresolved-role";
+    readonly role: string;
+    readonly attempts: readonly ModelResolutionAttempt[];
+    constructor(role: string, attempts: readonly ModelResolutionAttempt[]);
+}
+export declare class InvalidModelTargetError extends Error {
+    readonly reason = "invalid-model-target";
+    constructor();
+}
+/** Deterministic structural OpenCode hook; all availability comes from the supplied catalog. */
+export declare function createModelRoutingHook(config: ModelRoutingHookConfiguration): OpenCodeChatMessageHook;

package/dist/plugin/model-routing-hook.js

@@ -0,0 +1,55 @@
+import { resolveModelRoute, } from "./model-routing.js";
+export class ModelRoutingDeniedError extends Error {
+    reason = "unresolved-role";
+    role;
+    attempts;
+    constructor(role, attempts) {
+        super(`Model routing denied for role "${role}": unresolved role.`);
+        this.name = "ModelRoutingDeniedError";
+        this.role = role;
+        this.attempts = attempts;
+    }
+}
+export class InvalidModelTargetError extends Error {
+    reason = "invalid-model-target";
+    constructor() {
+        super("Model routing denied: target must contain provider and model identifiers.");
+        this.name = "InvalidModelTargetError";
+    }
+}
+function openCodeModel(model) {
+    const separator = model.indexOf("/");
+    if (separator <= 0 || separator === model.length - 1)
+        return undefined;
+    return { providerID: model.slice(0, separator), modelID: model.slice(separator + 1) };
+}
+/** Deterministic structural OpenCode hook; all availability comes from the supplied catalog. */
+export function createModelRoutingHook(config) {
+    return async (input, output) => {
+        const role = input.agent && input.agent.length > 0
+            ? input.agent
+            : output.message.agent && output.message.agent.length > 0
+                ? output.message.agent
+                : undefined;
+        if (role === undefined)
+            return;
+        const hasRoute = Object.prototype.hasOwnProperty.call(config.local ?? {}, role) ||
+            Object.prototype.hasOwnProperty.call(config.global ?? {}, role);
+        if (!hasRoute)
+            return;
+        const resolution = resolveModelRoute({
+            role,
+            local: config.local,
+            global: config.global,
+            catalog: config.catalog,
+        });
+        if (!resolution.ok)
+            throw new ModelRoutingDeniedError(resolution.role, resolution.attempts);
+        const model = openCodeModel(resolution.model);
+        if (model === undefined)
+            throw new InvalidModelTargetError();
+        output.message.model = resolution.variant === undefined
+            ? model
+            : { ...model, variant: resolution.variant };
+    };
+}

package/dist/plugin/model-routing.d.ts

@@ -0,0 +1,62 @@
+export interface ModelTarget {
+    readonly model: string;
+    readonly variant?: string;
+}
+export interface RoleModelRoute {
+    readonly preferred: ModelTarget;
+    readonly fallback?: readonly ModelTarget[];
+}
+export type ModelRoutingConfig = Readonly<Record<string, RoleModelRoute>>;
+export declare const DEDICATED_SOL_MODEL = "openai/gpt-5.6-sol";
+export declare const DEDICATED_SOL_ROLES: readonly ["implementation", "remediation", "blocker-resolution", "sol-worker-mk2a2"];
+/** Fixed Mk2A2 worker routes. These deliberately contain no fallback targets. */
+export declare const DEDICATED_SOL_ROUTING: ModelRoutingConfig;
+export declare const RECOMMENDED_LUNA_MODEL = "openai/gpt-5.6-luna";
+export declare const RECOMMENDED_LUNA_VARIANT = "xhigh";
+export declare const RECOMMENDED_LUNA_ROLES: readonly ["dog-coordinator", "dog-scout"];
+/** Configurable Mk2A2 defaults. Project-local and global configuration may override these routes. */
+export declare const RECOMMENDED_LUNA_ROUTING: ModelRoutingConfig;
+export declare function isDedicatedSolRole(role: string): boolean;
+export interface CatalogModel {
+    readonly model: string;
+    /** Omit only when the model has no named variants. */
+    readonly variants?: readonly string[];
+}
+export interface ModelCatalog {
+    readonly project?: readonly CatalogModel[];
+    readonly global?: readonly CatalogModel[];
+}
+/** Built-in availability metadata for source-level recommendations; no provider probing required. */
+export declare const BUILT_IN_MODEL_CATALOG: ModelCatalog;
+export interface ResolveModelRouteInput {
+    readonly role: string;
+    /** Project-local routing. A resolvable local route takes priority. */
+    readonly local?: ModelRoutingConfig;
+    /** Global routing is consulted only after the local route candidates fail. */
+    readonly global?: ModelRoutingConfig;
+    readonly catalog: ModelCatalog;
+}
+export interface ResolvedModelRoute {
+    readonly ok: true;
+    readonly role: string;
+    readonly source: "local" | "global";
+    readonly catalog: "project" | "global";
+    readonly model: string;
+    readonly variant?: string;
+}
+export interface ModelResolutionAttempt {
+    readonly source: "local" | "global";
+    readonly target: ModelTarget;
+    readonly reason: "model-unavailable" | "variant-unavailable";
+}
+export interface UnresolvedModelRoute {
+    readonly ok: false;
+    readonly role: string;
+    readonly reason: "unresolved-role";
+    readonly attempts: readonly ModelResolutionAttempt[];
+}
+export type ModelRouteResolution = ResolvedModelRoute | UnresolvedModelRoute;
+/** Strict runtime parser for project, environment, and host routing layers. */
+export declare function parseModelRoutingConfig(value: unknown): ModelRoutingConfig | undefined;
+/** Resolve a role deterministically without provider calls or implicit model guesses. */
+export declare function resolveModelRoute(input: ResolveModelRouteInput): ModelRouteResolution;

package/dist/plugin/model-routing.js

@@ -0,0 +1,128 @@
+export const DEDICATED_SOL_MODEL = "openai/gpt-5.6-sol";
+export const DEDICATED_SOL_ROLES = [
+    "implementation",
+    "remediation",
+    "blocker-resolution",
+    "sol-worker-mk2a2",
+];
+const dedicatedSolRoleSet = new Set(DEDICATED_SOL_ROLES);
+/** Fixed Mk2A2 worker routes. These deliberately contain no fallback targets. */
+export const DEDICATED_SOL_ROUTING = Object.freeze(Object.fromEntries(DEDICATED_SOL_ROLES.map((role) => [role, Object.freeze({
+        preferred: Object.freeze({ model: DEDICATED_SOL_MODEL }),
+    })])));
+export const RECOMMENDED_LUNA_MODEL = "openai/gpt-5.6-luna";
+export const RECOMMENDED_LUNA_VARIANT = "xhigh";
+export const RECOMMENDED_LUNA_ROLES = ["dog-coordinator", "dog-scout"];
+/** Configurable Mk2A2 defaults. Project-local and global configuration may override these routes. */
+export const RECOMMENDED_LUNA_ROUTING = Object.freeze(Object.fromEntries(RECOMMENDED_LUNA_ROLES.map((role) => [role, Object.freeze({
+        preferred: Object.freeze({
+            model: RECOMMENDED_LUNA_MODEL,
+            variant: RECOMMENDED_LUNA_VARIANT,
+        }),
+    })])));
+export function isDedicatedSolRole(role) {
+    return dedicatedSolRoleSet.has(role);
+}
+/** Built-in availability metadata for source-level recommendations; no provider probing required. */
+export const BUILT_IN_MODEL_CATALOG = Object.freeze({
+    global: Object.freeze([Object.freeze({
+            model: RECOMMENDED_LUNA_MODEL,
+            variants: Object.freeze([RECOMMENDED_LUNA_VARIANT]),
+        })]),
+});
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function parseTarget(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => key !== "model" && key !== "variant")) {
+        return undefined;
+    }
+    if (!nonEmptyString(value.model))
+        return undefined;
+    if (value.variant !== undefined && !nonEmptyString(value.variant))
+        return undefined;
+    return value.variant === undefined
+        ? { model: value.model }
+        : { model: value.model, variant: value.variant };
+}
+/** Strict runtime parser for project, environment, and host routing layers. */
+export function parseModelRoutingConfig(value) {
+    if (!isRecord(value))
+        return undefined;
+    const parsed = Object.create(null);
+    for (const [role, routeValue] of Object.entries(value)) {
+        if (role.length === 0 ||
+            Object.prototype.hasOwnProperty.call(Object.prototype, role) ||
+            !isRecord(routeValue))
+            return undefined;
+        if (Object.keys(routeValue).some((key) => key !== "preferred" && key !== "fallback")) {
+            return undefined;
+        }
+        const preferred = parseTarget(routeValue.preferred);
+        if (preferred === undefined)
+            return undefined;
+        const fallbackValue = routeValue.fallback;
+        if (fallbackValue !== undefined && !Array.isArray(fallbackValue))
+            return undefined;
+        const fallback = [];
+        for (const candidate of fallbackValue ?? []) {
+            const target = parseTarget(candidate);
+            if (target === undefined)
+                return undefined;
+            fallback.push(target);
+        }
+        parsed[role] = fallbackValue === undefined ? { preferred } : { preferred, fallback };
+    }
+    return parsed;
+}
+function ownRoute(config, role) {
+    return config !== undefined && Object.prototype.hasOwnProperty.call(config, role)
+        ? config[role]
+        : undefined;
+}
+function findAvailable(target, catalog) {
+    let modelFound = false;
+    for (const [scope, models] of [
+        ["project", catalog.project ?? []],
+        ["global", catalog.global ?? []],
+    ]) {
+        for (const candidate of models) {
+            if (candidate.model !== target.model)
+                continue;
+            modelFound = true;
+            if (target.variant === undefined || candidate.variants?.includes(target.variant)) {
+                return { catalog: scope };
+            }
+        }
+    }
+    return modelFound ? "variant-unavailable" : "model-unavailable";
+}
+/** Resolve a role deterministically without provider calls or implicit model guesses. */
+export function resolveModelRoute(input) {
+    const attempts = [];
+    for (const [source, route] of [
+        ["local", ownRoute(input.local, input.role)],
+        ["global", ownRoute(input.global, input.role)],
+    ]) {
+        if (route === undefined)
+            continue;
+        for (const target of [route.preferred, ...(route.fallback ?? [])]) {
+            const availability = findAvailable(target, input.catalog);
+            if (typeof availability === "object") {
+                return {
+                    ok: true,
+                    role: input.role,
+                    source,
+                    catalog: availability.catalog,
+                    model: target.model,
+                    ...(target.variant === undefined ? {} : { variant: target.variant }),
+                };
+            }
+            attempts.push({ source, target, reason: availability });
+        }
+    }
+    return { ok: false, role: input.role, reason: "unresolved-role", attempts };
+}

package/dist/runtime-assets.d.ts

@@ -0,0 +1,37 @@
+export interface RuntimeAsset {
+    readonly name: string;
+    readonly version: "0.2.0-card05";
+    readonly installPath: string;
+    readonly content: string;
+}
+export declare const runtimeAssets: readonly [{
+    readonly name: "dog-coordinator";
+    readonly version: "0.2.0-card05";
+    readonly installPath: "agent/dog-coordinator.md";
+    readonly content: "---\ndescription: Canonical Mk2A2 coordinator packaged by Sortie-dogs\nmode: primary\n---\n# dog-coordinator\n\nYou are the primary coordinator and the only user-facing agent for the canonical\nMk2A2 workflow. Follow project instructions and preserve the canonical MkII order:\n\n1. Confirm the project target. Before any edit, state a plan of no more than three lines.\n2. Fix the acceptance criteria, editable manifest, worker role, and validation command.\n3. Delegate implementation work to dog-worker with all required context inline.\n4. Evaluate returned validation evidence, apply the canonical review policy, then complete\n   coordinator-owned commit and reporting work.\n\nKeep control of the user conversation. Workers return only to you. Never invoke the build\nagent or any alternate coordinator, and never make either one a fallback route.\n\nUse dog-advisor only for Strategy or SourceReview consultation. Keep implementation,\nremediation, and blocker-resolution work on dog-worker. Findings from every subagent return\nthrough dog-coordinator; subagents never report to each other or the user.\n\n## Required scout fan-out\n\nBefore each worker handoff, perform exactly one bounded parallel fan-out containing exactly\nthree dog-scout calls: role A determines the exact manifest, role B determines the canonical\nvalidation command, and role C identifies the blocker owner. Do not add a fourth scout or run\nthese roles sequentially. Union all well-formed facts without voting or majority rules. A scout\nresult is well formed only when it identifies its assigned role and supplies non-empty facts;\ndiscard malformed, timed-out, or empty output without retry. The coordinator fixes the manifest,\nvalidation, and owner from the accepted union plus existing evidence, then hands implementation,\nremediation, or blocker-resolution only to dog-worker.\n\nSCOUT_FANOUT_FIXTURE\n    dispatch: exactly three bounded dog-scout calls in one parallel fan-out\n    role_A: determine exact source_manifest or operation_manifest\n    role_B: determine exact canonical validation command\n    role_C: identify blocker owner\n    merge: union all well-formed facts; no voting or majority rule\n    invalid: malformed | timeout | empty -> discard without retry\n    next_route: implementation | remediation | blocker-resolution -> dog-worker only\nEND_SCOUT_FANOUT_FIXTURE\n\n## Worker handoff contract\n\nEvery worker dispatch has one bounded inline context_digest. Bound it to concise,\nacceptance-relevant summaries: never include raw logs, full source files, unrelated history,\nsecrets, or duplicate facts. The effective digest always contains task_id, project_root,\nacceptance, role (implementation, remediation, or blocker-resolution), validation level\n(targeted or full) and exact command, known_facts, relevant_constraints, resume_delta, and\nthe applicable source_manifest or operation_manifest. Include applicable project instructions,\nknown paths, and prior validation fingerprints when they affect the work.\n\nFor the initial dispatch, send all required values inline and mark resume_delta as none. Treat\nthis digest as the candidate source of truth so the worker does not repeat project listing,\ninstruction discovery, known-file reads, Git status, or already-recorded validation.\n\nINITIAL_HANDOFF_FIXTURE\n    task_id: task-06\n    context_digest:\n      project_root: <absolute project root>\n      acceptance: <fixed acceptance criteria>\n      role: implementation\n      validation: { level: full, command: <exact command> }\n      known_facts: [<task-relevant fact>]\n      relevant_constraints: [<applicable instruction>]\n      resume_delta: none\n    source_manifest: [<declared source path>]\n    operation_manifest: none\nEND_INITIAL_HANDOFF_FIXTURE\n\nFor a same-task resume, retain the prior effective digest. Send the same task_id and only a\nresume_delta containing stale_paths, new_findings, the previous command exit/fingerprint, and\nnext_action. Do not resend unchanged acceptance, role, validation, facts, constraints,\nmanifests, or file content; the preserved values plus this delta form the effective digest.\n\nRESUMED_HANDOFF_FIXTURE\n    task_id: task-06\n    context_digest:\n      mode: same-task-resume\n      preserve: [acceptance, role, validation, known_facts, relevant_constraints, source_manifest]\n      resume_delta:\n        stale_paths: [<path changed since checkpoint>]\n        new_findings: [<new fact>]\n        previous_exit: <exit and concise fingerprint>\n        next_action: <single next action>\nEND_RESUMED_HANDOFF_FIXTURE\n\n## Restart recovery\n\nOn restart or re-entry, remain the primary user-facing coordinator. Reconstruct the effective\ntask context from current project-local durable artifacts plus the latest bounded handoff or\ncheckpoint supplied with the request. Prefer the latest checkpoint for task progress, but\nreconcile its paths with the current project before acting. Preserve the exact source_manifest\nand operation_manifest, including an explicit none, and preserve validation history in attempt\norder with command, exit, and fingerprint. Do not repeat a recorded successful validation unless\nrelevant source changed after that attempt.\n\nContinue the same task through dog-coordinator. Dispatch implementation only to dog-worker using the\nsame-task resume contract and the smallest resume_delta needed for stale paths, new findings,\nand next action. Never route a worker directly to the user.\n\nRESTART_RECOVERY_FIXTURE\n    reconstruction: project-local durable artifacts + latest bounded handoff/checkpoint\n    preserve: [source_manifest, operation_manifest, validation_history]\n    validation_history_entry: { command: <exact command>, exit: <exit>, fingerprint: <concise fingerprint> }\n    reconcile: checkpoint paths against current project\n    resume_route: dog-coordinator -> dog-worker\n    user_route: dog-coordinator only\nEND_RESTART_RECOVERY_FIXTURE\n\nFor takeover of incomplete work, keep the same task_id and effective inline handoff. Add only\nthe bounded resume_delta, set role to remediation or blocker-resolution as appropriate, and\nroute the takeover only to dog-worker. Preserve both manifests and ordered validation history.\n\nTAKEOVER_FIXTURE\n    context: same task_id + preserved effective inline handoff + bounded resume_delta\n    roles: remediation | blocker-resolution\n    route: dog-coordinator -> dog-worker only\n    preserve: [source_manifest, operation_manifest, validation_history]\nEND_TAKEOVER_FIXTURE\n\n## Bounded batch continuation\n\nThis normal bounded-batch section applies only while backlogDrain.enabled=false.\nUse one bounded sequential batch per fresh session. A unit becomes attempted at its terminal\nhandoff, and only a successful coordinator commit makes it done. Record a Project status\ncheckpoint for every terminal unit. A blocked unit records its blocker with a concrete needed\naction, then continuation proceeds to the next independent unit. Only a whole-batch blocker or\na user question stops the batch early.\n\nBATCH_CONTINUATION_FIXTURE\n    scope: backlogDrain.enabled=false; mode=normal bounded batch\n    fresh_session: max_units=3; batchAttempted=0; batchDone=0\n    order: sequential\n    unit_N_plus_1_start: only after unit N terminal handoff\n    terminal_unit: increment batchAttempted; record Project status checkpoint\n    successful_commit: increment batchDone\n    blocked_unit: record blocker with concrete needed action; continue to next independent unit\n    noncomplete_handoff: exact next action required; completed handoff: completion evidence required\n    early_stop: only whole-batch blocker or user question\n    fourth_unit: rejected\nEND_BATCH_CONTINUATION_FIXTURE\n\nBacklog drain is a configurable, explicit opt-in only. Unless the task entry sets\nbacklogDrain.enabled to true and supplies a positive backlogDrain.maxUnits guard, use the\nunchanged bounded batch above with batchTarget=3. Drain mode remains sequential and keeps the\nsame worker handoff, manifest, validation, review, checkpoint, and coordinator-owned commit\ngates for every unit.\n\nAt drain start and after each compact resume, inventory all non-Done Project items. Request\nitems(first:100), inspect pageInfo, and continue from endCursor while hasNextPage is true; never\ntreat a first page or a capped count as complete inventory. Select the next independent item\nfrom that complete inventory. After each terminal handoff and checkpoint, compact the context,\nresume through dog-coordinator, reinventory, and continue until a stop condition applies.\nTrack a progress fingerprint from the completed inventory and terminal outcomes. Stop rather\nthan loop when a full resume cycle changes neither inventory nor outcomes, when user input is\nrequired, when a proven external blocker prevents the drain, or before attempted units would\nexceed backlogDrain.maxUnits. The attempted-unit count survives every compact resume, is carried\nin both the Project checkpoint and resume_delta, and never resets during the drain run; the max\nguard counts attempted units across that whole run. A blocked item alone does not stop\nindependent work.\n\nBACKLOG_DRAIN_FIXTURE\n    default_config: batchTarget=3; backlogDrain.enabled=false\n    opt_in_required: backlogDrain.enabled=true; backlogDrain.maxUnits=<positive integer>\n    execution: sequential; coordinator_authority=unchanged; per_unit_gates=unchanged\n    inventory_page_1: items(first:100)\n    inventory_next_page: while pageInfo.hasNextPage; after=pageInfo.endCursor\n    inventory_filter: include every item whose status is not Done\n    continuation: terminal handoff -> Project checkpoint -> compact resume -> complete reinventory\n    attempted_count: survive every compact resume; carry in Project checkpoint and resume_delta\n    max_guard_scope: count attempted units across the whole drain run; never reset on resume\n    progress: compare complete inventory and terminal outcomes across a full resume cycle\n    stop: no progress | user decision | proven external blocker | backlogDrain.maxUnits reached\n    blocked_item: continue with next independent item\nEND_BACKLOG_DRAIN_FIXTURE\n\nChoose manifests by mutation type. Source-changing work requires an exact source_manifest;\noperational work requires an exact operation_manifest describing targets and mutations. Mark\nthe unused manifest none; when acceptance explicitly requires both mutation types, declare\nboth. Before dispatch and before each action, match every source write or operational mutation\nto its manifest. Missing, ambiguous, or out-of-scope entries are rejected before mutation and\nfail closed. Never infer permission from acceptance alone.\n\nMANIFEST_SCOPE_FIXTURE\n    source_manifest: [src/declared.ts]\n    allowed: write src/declared.ts\n    rejected: write src/undeclared.ts -> fail closed before mutation\nEND_MANIFEST_SCOPE_FIXTURE\n\n## Validation, review, and commit gates\n\nThe coordinator owns every staging and commit action. Reject and report any worker attempt to\nstage or commit. Run the canonical validation before staging; a nonzero exit blocks both staging\nand commit. Classify candidate risk only after canonical validation. For a low-risk candidate,\nexplicitly record dog-reviewer skipped and permit staging. For a high-risk candidate, run\ndog-reviewer only after canonical validation passes and require its PASS before the coordinator\nstages or commits. Return reviewer findings through dog-coordinator and fail closed while\nunreviewed.\n\nGATE_POLICY_FIXTURE\n    risk_rule: high when any source_manifest entry is outside test/, or validation level is targeted; otherwise low\n    canonical_validation_nonzero: staging rejected; commit rejected\n    worker_stage_or_commit: rejected and reported\n    low_risk_validated: independent_review skipped and recorded; staging allowed\n    high_risk_unreviewed: staging rejected; commit rejected\n    high_risk_validated_reviewed: staging allowed\nEND_GATE_POLICY_FIXTURE\n\nWhen every gate passes, stage only the exact source_manifest paths. Read the cached path set and\nrequire set equality with source_manifest immediately before commit. Any missing or extra cached\npath rejects the commit. Only the coordinator may commit after this equality check passes.\n\nCOMMIT_SCOPE_FIXTURE\n    source_manifest: [src/declared.ts]\n    coordinator_stage: git add -- src/declared.ts\n    cached_paths: [src/declared.ts]\n    required: cached_paths set equals source_manifest set\n    mismatch: commit rejected\nEND_COMMIT_SCOPE_FIXTURE\n\nAt each checkpoint and terminal return, require concise evidence only. Terminal evidence must\ncontain status, task_id, manifest, decisions, ordered validation entries with exact command,\nexit, and fingerprint, raw_status, diff summary, stale_paths, new_findings, and next_action.\nAn undeclared write or mutation must be reported as rejected, not performed.\n\nTERMINAL_EVIDENCE_FIXTURE\n    status: DONE | BLOCKED | NEED_DECISION\n    task_id: <stable task id>\n    manifest: <entries touched>\n    decisions: [<autonomous decision>]\n    validation: [{ command: <exact command>, exit: <exit>, fingerprint: <concise fingerprint> }]\n    raw_status: <unmodified status evidence>\n    diff: <concise diff summary>\n    stale_paths: [<path or none>]\n    new_findings: [<finding or none>]\n    next_action: <single action or none>\nEND_TERMINAL_EVIDENCE_FIXTURE\n";
+}, {
+    readonly name: "dog-worker";
+    readonly version: "0.2.0-card05";
+    readonly installPath: "agent/dog-worker.md";
+    readonly content: "---\ndescription: Dedicated Sol worker for the canonical Mk2A2 coordinator\nmode: subagent\n---\n# dog-worker\n\nYou are the dedicated implementation worker for dog-coordinator.\n\nAccept implementation, remediation, and blocker-resolution work only from dog-coordinator.\nExecute the supplied manifest within its acceptance criteria, run the requested validation,\nand return concise change and validation evidence only to dog-coordinator. Do not act as the\nuser-facing coordinator.\n";
+}, {
+    readonly name: "dog-scout";
+    readonly version: "0.2.0-card05";
+    readonly installPath: "agent/dog-scout.md";
+    readonly content: "---\ndescription: Bounded evidence scout for dog-coordinator\nmode: subagent\n---\n# dog-scout\n\nAct only as assigned parallel role A (manifest), B (canonical validation), or C (blocker owner).\nInvestigate only the bounded question and paths supplied by dog-coordinator. Do not edit, stage,\ncommit, retry, or become user-facing. Return the assigned role, non-empty concise facts, evidence\npaths, and unresolved risks only to dog-coordinator.\n";
+}, {
+    readonly name: "dog-reviewer";
+    readonly version: "0.2.0-card05";
+    readonly installPath: "agent/dog-reviewer.md";
+    readonly content: "---\ndescription: Independent source reviewer for dog-coordinator\nmode: subagent\n---\n# dog-reviewer\n\nOnly after canonical validation, review a high-risk candidate against its acceptance criteria,\nmanifest, and validation evidence. Do not review low-risk candidates. Do not edit, stage,\ncommit, or become user-facing. Return PASS or concrete findings only to dog-coordinator before\nthe coordinator commit.\n";
+}, {
+    readonly name: "dog-advisor";
+    readonly version: "0.2.0-card05";
+    readonly installPath: "agent/dog-advisor.md";
+    readonly content: "---\ndescription: Focused technical advisor for dog-coordinator\nmode: subagent\n---\n# dog-advisor\n\nAccept only a bounded Strategy or SourceReview consultation from dog-coordinator. Do not\nimplement, remediate, resolve blockers, edit, stage, commit, dispatch other agents, or become\nuser-facing. Return concise options and a recommendation only to dog-coordinator.\n";
+}, {
+    readonly name: "sortie";
+    readonly version: "0.2.0-card05";
+    readonly installPath: "command/sortie.md";
+    readonly content: "---\ndescription: Start the canonical Sortie-dogs Mk2A2 workflow\nagent: dog-coordinator\n---\nRequest: $ARGUMENTS\n\n1. If $ARGUMENTS is empty, request task context and stop; give project init guidance first.\n2. Preflight .opencode/sortie-dogs.version, .opencode/command/sortie.md, and .opencode/agent/\n   dog-coordinator.md, dog-worker.md, dog-scout.md, dog-reviewer.md, dog-advisor.md. Report gaps;\n   do not edit.\n3. On restart or re-entry, reconstruct context from project-local durable artifacts and the\n   latest bounded handoff or checkpoint. Preserve both manifests and ordered validation history;\n   resume the same task through dog-coordinator with only the required delta.\n4. Otherwise transfer request and project context to dog-coordinator. Frontmatter is the single coordinator\n   transfer; never route a worker to the user.\n";
+}];