sortie-dogs 0.10.15 → 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-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" &&

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

@@ -486,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;

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.15",
+  "version": "0.10.18",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",