sortie-dogs 0.10.14 → 0.10.18

package/README.md

@@ -106,6 +106,37 @@ The pre-v0.10.6 local benchmark condition is closed historical evidence. New
 development decisions use SWE-bench measurements collected under the frozen
 contract in [Coding benchmark completion and correctness](docs/benchmark-completion-contract.md).
 
+### v0.10.14 SWE-bench Lite dev23 baseline
+
+The first complete v0.10.14 baseline was run against all 23 `dev` instances and
+graded with the pinned official harness. It is a fixed candidate baseline, not a
+leaderboard or general success-rate claim.
+
+- Candidate: `sortie-dogs@0.10.14`, package SHA-256
+  `f2caf67268a5f69b67a252a0d84bfc5ad09db82684aa8c1e0f5c49f8d2986993`.
+- Dataset: `princeton-nlp/SWE-bench_Lite`, revision
+  `6ec7bb89b9342f664a54a6e0a6ea6501d3437cc2`, split `dev`.
+- Conditions: pass@1, `attempts_per_instance=1`, `retry_count=0`, per-instance
+  inference limit `$1.50`, four independent inference slots, and official
+  scoring with `max_workers=1`.
+- Official score: **6/23 (26.1%)**. All 23 rows received an official result.
+- Resolved instances: `marshmallow-code__marshmallow-1343`,
+  `marshmallow-code__marshmallow-1359`, `pydicom__pydicom-1256`,
+  `pydicom__pydicom-1694`, `pylint-dev__astroid-1333`, and
+  `sqlfluff__sqlfluff-1733`.
+- Inference spend: `$15.7542788` under the separate `$50` v0.10.14 campaign.
+- Environment deviations retained in the result: five `pvlib` rows hit the
+  NumPy 2.0 removal of `np.Inf`, and `pyvista__pyvista-4315` lacked
+  `libGL.so.1`. These rows remain in the denominator and were not silently
+  removed.
+- Four non-successful inference terminals (`timeout` or `patch-index-failed`)
+  produced empty patches and are counted as unresolved official results.
+
+This baseline is the comparison point for any later v0.10.15 candidate. A
+later candidate must use its own package digest and preserve the same dataset,
+official scoring boundary, and declared budget conditions before its score is
+compared with this value.
+
 ## Historical local case study
 
 These are completion-filtered local references on one frozen DeepSWE task,

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

@@ -73,6 +73,11 @@ export interface OperatorProposalState {
     readonly intent: OperatorIntent;
     goal_binding: OperatorProposalGoalBinding | null;
     readonly created_at: string;
+    /** Frozen carry-in spend; unlike live counters it must not change the admitted Task identity. */
+    readonly prior_spend?: {
+        readonly reads: number;
+        readonly submissions: number;
+    };
     phase: "investigating" | "submitted" | "approved";
     proposal_call_id: string | null;
     proposal_session_id: string | null;

package/dist/core/operator-proposal.js

@@ -101,6 +101,25 @@ export class OperatorProposalBudgetError extends Error {
     }
 }
 function parseIntent(value) {
+    if (record(value) && Array.isArray(value.allow_read)) {
+        const diagnostics = [];
+        value.allow_read.forEach((path, index) => {
+            if (normalizedRelativePath(path))
+                return;
+            let expected = "existing repository-relative file or directory; external absolute paths are not proposal read scopes";
+            if (typeof path === "string") {
+                try {
+                    expected = normalizeRelativePath(path);
+                }
+                catch { /* Never authorize an external or traversal path. */ }
+            }
+            diagnostics.push({ document: "proposal", pointer: `/allow_read/${index}`, code: "operator-intent-read-path-invalid",
+                rule: "normalized-relative-path", repair_kind: "repair-field", repair_paths: [`/allow_read/${index}`],
+                expected, actual_type: jsonType(path) });
+        });
+        if (diagnostics.length)
+            throw new OperatorContractError(diagnostics);
+    }
     const proposalBudget = record(value) && Object.hasOwn(value, "proposal_budget")
         ? value.proposal_budget
         : DEFAULT_OPERATOR_PROPOSAL_BUDGET;
@@ -392,6 +411,11 @@ export class OperatorProposalRuntime {
                 `original_request: ${state.intent.original_request.text}`, "ordered_requirements:", ...state.intent.requirements.map(item => `- ${item.id} [${item.kind}]: ${item.text}`),
                 `authoritative_refs: ${JSON.stringify(state.intent.authoritative_refs)}`, `allow_read: ${JSON.stringify(state.intent.allow_read)}`,
                 `proposal_budget: ${JSON.stringify(state.intent.proposal_budget)}`,
+                "要件に相談や利用者判断が含まれる場合、workerから追加Taskを呼ぶ計画にしない。rootが派遣前に必要な相談を行い、確認済みの素材許諾・選択・画像参照・決定をunit.objectiveと許可された入力へ明記する。子はroot会話を自動継承しない。未確定の判断だけを未確定として保持し、確認済み事項を再質問させない。実機測定や利用者Goの未達をfixtureで代替しない。",
+                ...(state.prior_spend ? [`prior_proposal_spend: ${JSON.stringify(state.prior_spend)}; remaining_at_start: ${JSON.stringify({
+                        reads: state.intent.proposal_budget.max_reads - state.prior_spend.reads,
+                        submissions: state.intent.proposal_budget.max_submissions - state.prior_spend.submissions
+                    })}. These are cumulative limits, not fresh grants. budget_estimate.proposal_reads must include prior_proposal_spend.reads plus reads charged in this investigation. Prior read paths are not evidence for this new child.`] : []),
                 "proposal packet fields: schema_version, revision, coverage[{requirement_id,approach,validation}], existing_surface[{requirement_id,path,form}], uncovered[{requirement_id,reason}], negative_handling[{requirement_id,handling}], read_scope, write_scope, budget_estimate{proposal_reads,execution_units}, plan{schema_version,acceptance_proof,source_refs,goal_declaration,units, optional git_lifecycle}. revisionは正のJSON整数。例: \"revision\":1。文字列\"revision\":\"1\"は禁止し、hostは型変換しない。plan.acceptanceは生成・提出せず省略し、hostがdurable intent.requirementsのtextを同順・完全一致でmaterializeする。legacy互換として明示する場合だけ同じ全文・順序を完全一致で使い、null・部分集合・並べ替え・空白/大小文字変更は禁止。acceptance_ids等の代替field禁止。",
                 "schema_versionはpacketとplanの両方で必ず文字列\"0.1\"。coverageはnegative/qualityを含む全ordered requirement IDを各1回含める（未対応だけuncoveredへ移す）。全declared criterion IDをacceptance_proofから参照し、各unitのacceptance_indicesはnonempty、全acceptance indexとexact validation commandを既存parser規則どおり完全coverageする。",
                 "plan.acceptance_proofは各acceptanceに対応するcriterion IDの配列を並べた二重配列。複数acceptanceを同じexact commandが証明する場合はcriterion IDを共有可で、acceptanceごとの固有criterion作成は不要。goal_declarationはobject。delivery_intent=\"implementation\", delivery_mode=\"mvp-first\", usable_path_established=false, controlled_change=false, goal_budget_unitsは正整数。criteria各要素はcriterion_idとvalidation_commandを持つ。",
@@ -466,6 +490,7 @@ export class OperatorProposalRuntime {
         const state = { schema_version: "0.1", profile: this.profile.id, root_session_id: root,
             intent_id: `intent-${intentHash.slice(0, 24)}`, intent_hash: intentHash, intent, created_at: new Date().toISOString(), phase: "investigating",
             goal_binding: null, proposal_call_id: null, proposal_session_id: null, read_count: spend.reads, read_paths: [], submission_count: spend.submissions, proposal_id: null,
+            ...(spend.reads > 0 || spend.submissions > 0 ? { prior_spend: { reads: spend.reads, submissions: spend.submissions } } : {}),
             proposal_revision: null, proposal_hash: null, proposal: null, approval_rationale: null };
         this.assertBudgetAvailable(state);
         await this.save(state);

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

@@ -237,6 +237,8 @@ export declare class OperatorRuntime {
     propose(root: string, raw: unknown, scopeApprovalTurnID?: string): Promise<OperatorProposal>;
     private proposeOnce;
     repair(root: string, draftID: string, patches: unknown): Promise<OperatorProposal>;
+    /** A diagnosed spelling repair may not add, widen, or redirect a read grant. */
+    private sameReadTarget;
     private prepareOnce;
     operatorTask(state: OperatorState): OperatorTask;
     /** Root-visible handle for the bounded operations delegate; its contract stays host-internal. */

package/dist/core/operator-runtime.js

@@ -5,7 +5,7 @@ import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { acceptanceContinuityFingerprint, inspectAcceptanceContinuity, normalizeAcceptanceCriteria, ACCEPTANCE_CONTINUITY_EXTENSION, MAX_ACCEPTANCE_CONTINUITY_BYTES, MAX_ACCEPTANCE_CRITERIA } from "./acceptance-continuity.js";
 import { expandGoalDeclaration, goalDeclarationDefaults, hasGoalCommandAliasConflict } from "./goal-declaration-format.js";
-import { normalizeRelativePath } from "./path.js";
+import { normalizeManifestPath, normalizeRelativePath } from "./path.js";
 import { CONTRACT_TEXT_LIMITS, validateHandoffSchema, validateOperationManifestSchema } from "./validate-schema.js";
 import { validateManifest } from "./validate-manifest.js";
 import { profileAgent, RUNTIME_PROFILES } from "./runtime-profile.js";
@@ -574,6 +574,17 @@ export class OperatorRuntime {
                 if (!record(patch) || !exactKeys(patch, ["op", "path", "value"]) || !["replace", "add"].includes(String(patch.op)) || typeof patch.path !== "string" || !Object.hasOwn(patch, "value")) {
                     throw new Error("operator-repair-invalid");
                 }
+                const readMatch = /^\/units\/(0|[1-9]\d*)\/read\/(0|[1-9]\d*)$/.exec(patch.path);
+                if (readMatch) {
+                    const unitIndex = Number(readMatch[1]), pathIndex = Number(readMatch[2]);
+                    const diagnosed = Array.isArray(draft.diagnostics) && draft.diagnostics.some((item) => item.document === "plan" && item.pointer === patch.path && item.code === "operator-scope-invalid");
+                    if (patch.op !== "replace" || !diagnosed ||
+                        !await this.sameReadTarget(original.units[unitIndex]?.read?.[pathIndex], patch.value)) {
+                        throw new Error("operator-repair-path-forbidden");
+                    }
+                    draft.plan.units[unitIndex].read[pathIndex] = patch.value;
+                    continue;
+                }
                 if (patch.path === "/git_lifecycle/post_commit_validation") {
                     const finalValidation = original.units.at(-1)?.validation;
                     if (patch.op !== "replace" || !strings(patch.value, true) || !Array.isArray(finalValidation) ||
@@ -625,6 +636,25 @@ export class OperatorRuntime {
             return this.proposeOnce(root, draft.plan);
         });
     }
+    /** A diagnosed spelling repair may not add, widen, or redirect a read grant. */
+    async sameReadTarget(before, after) {
+        if (!text(before) || !text(after))
+            return false;
+        try {
+            if (normalizeRelativePath(after) !== after)
+                return false;
+            const original = normalizeManifestPath(before);
+            if (original.kind === "relative")
+                return original.path === after;
+            if (!isAbsolute(original.path))
+                return false;
+            const [left, right] = await Promise.all([realpath(original.path), realpath(resolve(this.projectRoot, after))]);
+            return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
+        }
+        catch {
+            return false;
+        }
+    }
     async prepareOnce(root, raw, scopeApprovalTurnID) {
         const previous = await this.read(root);
         let immutableReplacement = previous?.phase === "cancelled" &&
@@ -797,6 +827,7 @@ export class OperatorRuntime {
                 "validation:", ...unit.validation.map(value => `  - ${value}`),
                 "Execute validation in its declared order. Earlier entries may be approved generator, build, formatter, or exact cleanup commands required before canonical criterion tests. Every persistent or transient generator output must be declared in unit.write. Cleanup may remove only declared unit.write outputs and must be an explicit ordered command after generation and before post-commit or canonical validation; never add an ignore rule or remove an undeclared path. If any necessary command, input, output, or cleanup is missing, do not run an undeclared command or variant and do not use resume evidence tooling to invent permission; return a contract-repair decision.",
                 "Preserve existing public API success and error return semantics unless acceptance explicitly changes them, and cover those compatibility boundaries in the declared validation.",
+                "Do not spawn nested subagents for consultation. Required consultations belong to the root before dispatch; use the confirmed decisions and evidence declared in the unit objective and inputs. If required consultation results or user decisions are missing, return the exact contract gap to the parent instead of attempting a deeper Task, inventing consent, or asking the user to repeat an already recorded decision.",
                 ...(plan.git_lifecycle !== undefined && index === plan.units.length - 1 ? [
                     `git_post_commit_validation: ${JSON.stringify(plan.git_lifecycle.post_commit_validation)}`,
                     "Complete every source write before invoking any git_post_commit_validation command. Its first exact invocation is the host commit boundary; after it, source mutation and undeclared shell commands are denied. Run every listed command and return its real evidence.",

package/dist/core/worktree-lifecycle.d.ts

@@ -51,6 +51,7 @@ export declare class WorktreeLifecycle {
     private readonly inFlight;
     private writeQueue;
     private transactionQueue;
+    private preparationQueue;
     private transactionLease;
     private readonly directParentAttestations;
     private constructor();
@@ -83,6 +84,7 @@ export declare class WorktreeLifecycle {
     private attestDirectParent;
     private exactEntry;
     private createAndLock;
+    private createAndLockOnce;
     private addWorktree;
     private requireOwnedRecord;
     private isDirectManagedPath;

package/dist/core/worktree-lifecycle.js

@@ -139,6 +139,7 @@ export class WorktreeLifecycle {
     inFlight = new Set();
     writeQueue = Promise.resolve();
     transactionQueue = Promise.resolve();
+    preparationQueue = Promise.resolve();
     transactionLease;
     directParentAttestations = new Map();
     constructor(repositoryRoot, worktreeRoot, gitPath, commonGitDir, rootIdentity) {
@@ -831,7 +832,15 @@ export class WorktreeLifecycle {
             return undefined;
         return entry;
     }
-    async createAndLock(record) {
+    createAndLock(record) {
+        // Git scans sibling administrative directories while adding and attesting worktrees. A peer's
+        // not-yet-written commondir can make Git fail after branch creation. Publish one complete entry
+        // at a time under the inventory lease; setup hooks and later worker execution remain concurrent.
+        const prepared = this.preparationQueue.then(() => this.createAndLockOnce(record));
+        this.preparationQueue = prepared.then(() => undefined, () => undefined);
+        return prepared;
+    }
+    async createAndLockOnce(record) {
         await this.assertRootIdentity();
         if (!this.isDirectManagedRecord(record) || await lstat(record.path).catch(() => undefined) !== undefined ||
             await this.branchExists(record.branch))

package/dist/plugin/profiled.js

@@ -449,6 +449,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 return JSON.stringify(operators.packet(state));
             control.enableUnits(state.rootSessionID, state.units.length);
             return JSON.stringify({ profile: profile.id, run_id: state.runID, acceptance_fingerprint: state.acceptanceFingerprint,
+                dispatch_instruction: "Dispatch this exact Task in the foreground. Omit background or set it to false; background=true is not supported by the operator lifecycle. Required consultations belong to the root before dispatch; confirmed user decisions must already be in the approved unit objective and inputs, not appended to this Task reference.",
                 fast_path: state.units.length === 1, task: state.units.length === 1 ? operators.nextWorkerTask(state) : operators.dispatchTask(state) });
         }
         tools[prepare] = { description: `Freeze an approved serial operator plan. Invalid plans return bounded diagnostics and a draft_id for field-only repair; no worker is started. After operator-acceptance-remediation-required, cancel first and prepare only the same exact acceptance, a write scope within the prior approved union, and a Git lifecycle starting at the failed committed head; consumed goal budget is retained. Coordinator only. ${planContract}`,
@@ -485,7 +486,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await registerPreparedGoal(context.sessionID, state);
                 return preparedTask(state);
             } };
-        tools[repair] = { description: "Repair a root-owned draft with named fields, git_lifecycle branch/start/message fields, or an already-declared criterion command. Empty patches revalidate the saved draft without resending it. Acceptance, unit count and write scope remain fixed.",
+        tools[repair] = { description: "Repair a root-owned draft with named fields, git_lifecycle branch/start/message fields, or an already-declared criterion command. A diagnosed /units/i/read/j scope error may be replaced with a normalized repository-relative spelling of the same resource only: absolute inputs require an existing relative alias whose realpath is identical; read expansion, redirection, whole-array replacement and write-scope repair are forbidden. Empty patches revalidate the saved draft without resending it. Acceptance, unit count and write scope remain fixed.",
             args: { draft_id: stringSchema, patches_json: stringSchema }, execute: async (args, context) => {
                 await requireRoot(context.sessionID);
                 let patches;
@@ -549,17 +550,18 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const proposal = await proposals.read(context.sessionID);
                 const proposalNextAction = proposal?.phase === "investigating"
                     ? proposal.proposal_call_id !== null
-                        ? "proposal Task is already admitted; do not redispatch it or call operator_next. Continue submission repairs only in the same active claimed child. If that child terminated without submission, report the terminal proposal failure; remaining read or submission capacity does not authorize a new Task, budget reset, or replacement child. Only an explicit root decision to retry may call cancel_operator with reason=plain to release this grant, which discards the spent proposal accounting and never reuses the terminated child"
+                        ? "proposal Task is already admitted; do not redispatch it or call operator_next. Continue submission repairs only in the same active claimed child. If that child terminated or was interrupted without submission, an explicit root decision to retry may call cancel_operator with reason=plain to release this grant. Cancellation stops owned children and durably preserves cumulative reads/submissions and goal spend. Pass the returned retry_intent unchanged to begin_operator_proposal, then dispatch only its new exact Task within the remaining budget. Never reuse the terminated child, reset spend, or replace the goal or ordered requirements. Exhaustion requires an explicit cumulative budget revision, not a reset."
                         : proposal.submission_count >= proposal.intent.proposal_budget.max_submissions
                             ? "proposal submission budget exhausted; do not call operator_next; report the bounded proposal failure"
                             : "proposal is not submitted; do not call operator_next; complete or repair the bounded proposal submission"
                     : proposal?.phase === "submitted"
-                        ? "compare and approve the exact proposal; do not call operator_next before approval prepares a run"
+                        ? "compare and approve the exact proposal; do not call operator_next before approval prepares a run. Approval authorizes implementation, not product acceptance. Preserve every required live measurement, consultation and user approval as pending acceptance obligations; canonical commands do not substitute for them. Use the host budget counters, not plan.goal_declaration.goal_budget_units, for remaining capacity; approval validates the retained goal binding and execution budget. A bounded diagnostic run may use cancel_operator after admission without inventing a plan validation command for cancellation."
                         : "approved proposal has no operator run; do not call operator_next; reconcile the approval or preparation failure";
                 return JSON.stringify(state ? { ...await operatorPacket(state), ...(draft ? { pending_draft: draft } : {}),
                     ...(proposal ? { proposal: proposalIdentity(proposal) } : {}) }
                     : draft ? { ...draft, ...(proposal ? { proposal: proposals.packet(proposal) } : {}) }
                         : proposal ? { profile: profile.id, proposal: proposals.packet(proposal),
+                            goal_binding: proposal.goal_binding, budget: await control.currentBudget(context.sessionID),
                             ...(proposal.phase === "investigating" && proposal.proposal_call_id === null ? { task: proposals.referenceTask(proposal),
                                 dispatch_instruction: "Pass this short Task reference verbatim; the host expands it only inside the directly claimed proposal child." } : {}),
                             next_action: proposalNextAction }
@@ -587,8 +589,11 @@ export function createProfiledPlugin(profile, assetVersion) {
                     operatorTurnLifecycle.set(context.sessionID, "cancelled");
                     return JSON.stringify({ profile: profile.id, status: "cancelled", scope: "proposal",
                         released_proposal: discarded ? proposals.packet(discarded) : null,
+                        retry_intent: discarded?.intent ?? null,
+                        retained_goal_binding: discarded?.goal_binding ?? null,
                         next_action: "the bounded proposal grant is released and its spent reads/submissions are not restored; " +
-                            "begin a new proposal investigation only on an explicit root decision to retry, and never reuse the cancelled child" });
+                            "cumulative proposal and goal spend are preserved. On an explicit root decision to retry, pass retry_intent unchanged to begin_operator_proposal, " +
+                            "preserve the same goal and ordered requirements, and dispatch only the new exact Task within the remaining budget. Never reuse the cancelled child or reset any budget" });
                 }
                 const current = pending;
                 if (requestedReason === "acceptance-remediation" && current.decision !== "operator-acceptance-remediation-required")
@@ -772,6 +777,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                 catch (error) {
                     if (error instanceof OperatorProposalBudgetError)
                         return JSON.stringify(error.diagnostic);
+                    if (error instanceof OperatorContractError)
+                        return JSON.stringify({ status: "invalid-intent",
+                            diagnostics: error.diagnostics, next_action: "Repair only the diagnosed fields and retry begin_operator_proposal; preserve original_request and every ordered requirement. No proposal was admitted and no budget was spent." });
                     throw error;
                 }
                 state = await proposals.bindGoal(context.sessionID, await control.proposalGoalBinding(context.sessionID));

package/dist/plugin/v2.js

@@ -136,6 +136,11 @@ function legacyToolName(name) {
 function legacyToolInput(name, input) {
     const value = record(input) ? { ...input } : {};
     if (name === "subagent") {
+        if (value.background === true && typeof value.prompt === "string" && value.prompt.startsWith("SORTIE_OPERATOR_")) {
+            throw new Error("operator-background-dispatch-not-supported: retry the same exact Task with background omitted or false; no admission or budget reservation occurred. Operator dispatch requires foreground completion for lifecycle accounting.");
+        }
+        if (value.background === false)
+            delete value.background;
         if (typeof value.agent === "string")
             value.subagent_type = value.agent;
         if (typeof value.sessionID === "string")

package/dist/runtime-assets-v010.js

@@ -187,6 +187,10 @@ ${profile.toolPrefix}operator_status to recover the existing draft_id after an i
 Call ${profile.toolPrefix}repair_operator_plan with that draft_id and patches_json (field operations)
 to repair only /units/<index>/validation, acceptance_indices, title, or objective. This tool cannot change acceptance,
 unit count or write scope. Do not regenerate the full plan or collapse units to work around a mapping error.
+A diagnosed operator-scope-invalid at /units/<index>/read/<index> also permits replace with a normalized relative
+spelling of the same resource. An absolute input requires an existing relative alias with identical realpath.
+Repair each diagnosed entry using the newly returned draft_id; never widen or redirect reads, replace the whole
+read array, create an alias through this repair tool, or repair write scope.
 An empty patches_json array revalidates the saved draft without resending the full plan; prefer this after a runtime repair.
 The repair tool also permits add/replace of /goal_declaration/criteria/<index>/goal_validation_command (or validation_command)
 only when the exact command is already declared in the validation list of a unit assigned to that criterion.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.10.14",
+  "version": "0.10.18",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",