gcf-harness-aif-ext 0.6.0 → 0.6.1

package/README.md

@@ -11,7 +11,7 @@ The harness turns policy-as-text into an executable pipeline. It has **no memory
 
 ## Requirements
 
-- [`gcf-aif-ext`](../gcf-aif-ext) `^0.5.0` installed, with a `gcf/` tree in the project — declared as a peer dependency, and `gcf-harness init` refuses when the `gcf` command is not registered
+- [`gcf-aif-ext`](../gcf-aif-ext) `^0.5.3` installed, with a `gcf/` tree in the project — declared as a peer dependency, and `gcf-harness init` refuses when the `gcf` command is not registered
 - Claude Code 2.1.270+ (hooks, dynamic workflows) — the only supported runtime
 - AI Factory 2.x, Node.js ≥ 22.14
 
@@ -47,6 +47,8 @@ Updating keeps the hook entry valid — it points into the extension's install d
 
 0.5.1 is a fix release. During a run, `gcf/config.yml` is always readable, and a Grep inside `gcf/` reads only readset files. An import breaks a `depends:` cycle the pair checks closed and asks a D1 about it. It cuts a section longer than a segment at paragraphs, and lens and pair prompts carry a window around the quote. `/gcf-run` checks the plan against each pillar's invariant and asks each pillar's review question over the diff. Use it with core 0.4.1, which brings the parent feature into the readset.
 
+0.6.1 is a fix release, to update together with core 0.5.3. The run lock `.gcf-session/runs/<id>.lock` is created exclusively, and a lock left by a dead run is taken over; while it is live, the gate refuses the item to another run and the core refuses any move on it, `/gcf-run` on main included. A session whose log cannot open ends as an error and releases its claim.
+
 0.6.0 adds `ai-factory gcf-harness run` (a batch at once, a worktree and an agent session per item, then the integrator) and the `--worktree` mode of `/gcf-run`, whose session ritual now integrates the verified branches a dead run left. It requires `gcf-aif-ext` 0.5.0 (`gcf worktree`, `gcf integrate`, `gcf verify`) — update both together and run `ai-factory gcf init`. The DoD of `/gcf-run` is `ai-factory gcf verify <id>`, and the item's `live:` delta is written before it.
 
 0.4.1 is a patch release. `/gcf-run` now commits the implementation first, then flips the card to `built` in a second commit, with `built_at` set to the implementation commit's hash. Update the core to 0.3.1 together with the harness: without it, an audit run before a verdict makes the pre-commit gate refuse that verdict.

package/commands/harness.js

@@ -27,6 +27,8 @@ function itemProblem(id, item, report) {
     return `${id} is ${item.status} — only ready items are driven`;
   }
 
+  if (item.running) return `${id} is driven by another harness run — wait until it ends`;
+
   // A child of a feature paused after a death does not start: the decision may kill it.
   const parent = item.parent ? report.items.find((p) => p.id === item.parent) : null;
   if (parent?.status === 'awaiting-decision') {

package/commands/run.js

@@ -4,7 +4,7 @@
 // worktree, and the block is recorded on main — a worktree never writes gcf/ status.
 import { spawn, spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { mkdir, open, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdir, open, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
 export const DEFAULT_AGENT = 'claude -p';
@@ -57,23 +57,73 @@ async function outcomeOf(dir) {
   }
 }
 
+/** Whether a pid is a live process; EPERM is alive under another user. */
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+
+    return true;
+  } catch (e) {
+    return e.code === 'EPERM';
+  }
+}
+
 /**
  * One harness run per item at a time: `.gcf-session/runs/<id>.lock` holds the pid of the run
- * that drives it. A lock whose process is gone is taken over. Returns the release, or null.
+ * that drives it, created exclusively. A lock whose process is gone is taken over; the core
+ * refuses moves on the item while the lock is live. Returns the release, or null.
  */
 async function claim(logs, id) {
   const file = path.join(logs, `${id}.lock`);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    if (await create(file)) return () => rm(file, { force: true });
+    const text = await readFile(file, 'utf8').catch(() => null);
+    if (text === null) continue; // released meanwhile
+    const pid = Number(text.trim());
+    if (pid === process.pid) return () => rm(file, { force: true });
+    if (!(await dead(file, pid))) return null;
+    await clearDead(file, text);
+  }
+
+  return null;
+}
+
+/** Create the lock with this pid, or false when it exists. */
+async function create(file) {
   try {
-    const pid = Number((await readFile(file, 'utf8')).trim());
-    process.kill(pid, 0);
-    if (pid !== process.pid) return null;
-  } catch {
-    // no lock, or its process is gone
+    await writeFile(file, `${process.pid}\n`, { flag: 'wx' });
+
+    return true;
+  } catch (e) {
+    if (e.code !== 'EEXIST') throw e;
+
+    return false;
   }
+}
 
-  await writeFile(file, `${process.pid}\n`);
+/** A lock whose pid is gone, or that never got one and is old: its creator died writing it. */
+async function dead(file, pid) {
+  if (Number.isInteger(pid) && pid > 0) return !alive(pid);
+  const age = await stat(file).then(
+    (s) => Date.now() - s.mtimeMs,
+    () => 0,
+  );
 
-  return () => rm(file, { force: true });
+  return age > 10000;
+}
+
+/**
+ * Remove a dead lock under `<lock>.break`, as the core's main lock does: two runs that judged
+ * the same lock dead cannot both remove it, so neither deletes the other's fresh lock.
+ */
+async function clearDead(file, text) {
+  const breaker = `${file}.break`;
+  if (!(await create(breaker))) return;
+  try {
+    if ((await readFile(file, 'utf8').catch(() => null)) === text) await rm(file, { force: true });
+  } finally {
+    await rm(breaker, { force: true });
+  }
 }
 
 /** Whether the tip of the worktree's branch carries `GCF-Verified: <id>`. */
@@ -112,11 +162,15 @@ async function prepare(ids, core, logs) {
 
 /** One session per item, its output in `.gcf-session/runs/<id>.log`. */
 async function session(r, agent, logs) {
-  const log = await open(path.join(logs, `${r.id}.log`), 'a');
+  let log = null;
   try {
+    log = await open(path.join(logs, `${r.id}.log`), 'a');
+
     return { ...r, code: await startAgent(agent, r.id, r.dir, log.fd) };
+  } catch (e) {
+    return { ...r, code: null, error: e.message };
   } finally {
-    await log.close();
+    await log?.close();
     await r.release();
   }
 }
@@ -142,6 +196,7 @@ async function recordBlock(r, outcome, core) {
 /** The result line of an item the integrator handled, or why it has none. */
 function resultOf(run, integrated) {
   const done = integrated.find((x) => x.id === run.id);
+  if (!done && run.error) return { id: run.id, result: 'error', error: run.error };
   if (!done)
     return {
       id: run.id,

package/extension.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/lee-to/ai-factory/2.x/schemas/extension.schema.json",
   "name": "gcf-harness-aif-ext",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "GCF orchestration harness for Claude Code: one-command card pipeline, readset guard",
   "skills": [
     "skills/gcf-run",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gcf-harness-aif-ext",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "GCF orchestration harness for Claude Code: one-command card pipeline, readset guard",
   "type": "module",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "prepack": "node -e \"const p=require('./package.json'),e=require('./extension.json');if(p.version!==e.version)throw new Error('version mismatch: package.json '+p.version+' vs extension.json '+e.version)\""
   },
   "peerDependencies": {
-    "gcf-aif-ext": "^0.5.0"
+    "gcf-aif-ext": "^0.5.3"
   },
   "files": [
     "extension.json",