@stravica-ai/digital-operator-pa 0.1.22 → 0.1.23

package/dist/engineering-pa-cli/src/pa/io.mjs

@@ -24,6 +24,24 @@ export async function writeJson(path, value) {
   await writeFile(path, body, 'utf8');
 }
 
+/**
+ * Write a JSON file with O_CREAT|O_EXCL semantics. Refuses to overwrite
+ * an existing file (throws a Node error with `code === 'EEXIST'`).
+ *
+ * Same shape rules as `writeJson`: 2-space indent, trailing newline,
+ * parent directories created on demand. Callers that follow an
+ * allocate-then-write pattern use this to turn a same-author write race
+ * into an EEXIST they can retry at NNN+1, rather than the plain flag
+ * `'w'` behaviour where the second write silently clobbered the first.
+ * Same primitive `escalate.mjs` in `librarian-pr-intake` uses for the
+ * librarian's own allocator — the two writers now share one race model.
+ */
+export async function writeJsonExclusive(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  const body = JSON.stringify(value, null, 2) + '\n';
+  await writeFile(path, body, { encoding: 'utf8', flag: 'wx' });
+}
+
 /**
  * Ensure a directory exists. Returns the absolute path.
  */

package/dist/engineering-pa-cli/src/pa/work.mjs

@@ -26,7 +26,22 @@ import {
 } from '../../../engineering-pa-core/src/workItemId/index.mjs';
 
 import { getRepoRoot } from './repo-root.mjs';
-import { readJson, writeJson, ensureDir, listJsonFiles, today } from './io.mjs';
+import {
+  readJson,
+  writeJson,
+  writeJsonExclusive,
+  ensureDir,
+  listJsonFiles,
+  today,
+} from './io.mjs';
+
+// Upper bound on the O_CREAT|O_EXCL retry loop in `createWork`. Same
+// value the librarian-pr-intake allocator uses (`escalate.mjs`); both
+// close the same class of same-author race between allocator scan and
+// exclusive write. 99 is comfortably above any realistic burst — 999 is
+// the per-author-per-day NNN ceiling so a runaway loop still terminates
+// well below it.
+const MAX_ALLOCATE_RETRIES = 99;
 
 const STATUSES = new Set(['draft', 'planned', 'in-progress', 'blocked', 'done', 'archived']);
 
@@ -63,29 +78,22 @@ function validatePriority(priority) {
 }
 
 /**
- * Highest NNN already allocated for `dateStr` in THIS author's per-day
- * sequence. Legacy items (`w-YYYY-MM-DD-NNN` with no author segment)
- * do not count toward any author's sequence — each writer starts from
- * 001 on the day writer-scoping takes effect and existing legacy items
- * simply occupy a separate, older space.
+ * Highest NNN currently visible on disk for `dateStr` in THIS author's
+ * per-day sequence. Legacy items (`w-YYYY-MM-DD-NNN` with no author
+ * segment) do not count toward any author's sequence — each writer
+ * starts from 001 on the day writer-scoping takes effect and existing
+ * legacy items simply occupy a separate, older space.
  *
- * If 999 is already taken, throws — callers should treat as an
- * operational failure and report. In practice this is unreachable
- * because NNN is per-author-per-day, not shared.
+ * The value is a starting point for `createWork`'s allocate-write-retry
+ * loop, not a final answer: between the scan and the exclusive write,
+ * another same-author `pa work create` may have landed a same-NNN file
+ * (same-author write race, structurally possible when two operator
+ * sessions run concurrently on shared work/). The O_CREAT|O_EXCL retry
+ * in `createWork` is what closes that residual race.
  */
-async function nextWorkNumber(repoRoot, dateStr, author) {
-  const dir = join(repoRoot, 'work');
-  const files = await listJsonFiles(dir);
-  const max = maxNForAuthorOnDate(files, dateStr, author);
-  const next = max + 1;
-  if (next > 999) {
-    const err = new Error(
-      `no free work-item slot for ${dateStr} in author=${author} sequence (NNN exhausted)`,
-    );
-    err.exitCode = 2;
-    throw err;
-  }
-  return next;
+async function scanMaxNInWorkDir(workDir, dateStr, author) {
+  const files = await listJsonFiles(workDir);
+  return maxNForAuthorOnDate(files, dateStr, author);
 }
 
 /**
@@ -101,6 +109,15 @@ async function nextWorkNumber(repoRoot, dateStr, author) {
  * with an actionable message naming all three sources — a mint with no
  * author identity is the exact defect R1 exists to close, so we refuse
  * to fall back to any hard-coded default.
+ *
+ * Write is O_CREAT|O_EXCL via `writeJsonExclusive`. If two same-author
+ * `createWork` invocations race (same estate, same day, two operator
+ * sessions), the allocator scan may hand both callers the same base
+ * NNN; the first exclusive write lands and the second gets EEXIST,
+ * which the retry loop below resolves by trying NNN+1, NNN+2, ... up
+ * to `MAX_ALLOCATE_RETRIES`. Cross-writer collisions (different author
+ * tokens) are already structurally impossible after R1
+ * (w-2026-08-12-001) — this closes the residual same-author window.
  */
 export async function createWork(opts) {
   if (!opts.title) {
@@ -127,28 +144,48 @@ export async function createWork(opts) {
   await ensureDir(workDir);
 
   const dateStr = today();
-  const nnn = await nextWorkNumber(repoRoot, dateStr, author);
-  const id = buildWorkItemId({ date: dateStr, author, nnn });
-  const path = join(workDir, `${id}.json`);
-
-  const item = {
-    id,
-    projectId: opts.projectId || null,
-    title: opts.title,
-    category: opts.category || 'chore',
-    status: 'draft',
-    priority: opts.priority == null ? 2 : opts.priority,
-    owner: opts.owner || 'system-architect',
-    assignee: opts.assignee || opts.owner || 'system-architect',
-    created: dateStr,
-    updated: dateStr,
-    completedAt: null,
-    summary: opts.summary || '',
-    blocked: null,
-    links: [],
-  };
-  await writeJson(path, item);
-  return { id, path };
+  const baseN = await scanMaxNInWorkDir(workDir, dateStr, author);
+
+  for (let offset = 1; offset <= MAX_ALLOCATE_RETRIES; offset += 1) {
+    const nnn = baseN + offset;
+    if (nnn > 999) {
+      const err = new Error(
+        `no free work-item slot for ${dateStr} in author=${author} sequence (NNN exhausted)`,
+      );
+      err.exitCode = 2;
+      throw err;
+    }
+    const id = buildWorkItemId({ date: dateStr, author, nnn });
+    const path = join(workDir, `${id}.json`);
+    const item = {
+      id,
+      projectId: opts.projectId || null,
+      title: opts.title,
+      category: opts.category || 'chore',
+      status: 'draft',
+      priority: opts.priority == null ? 2 : opts.priority,
+      owner: opts.owner || 'system-architect',
+      assignee: opts.assignee || opts.owner || 'system-architect',
+      created: dateStr,
+      updated: dateStr,
+      completedAt: null,
+      summary: opts.summary || '',
+      blocked: null,
+      links: [],
+    };
+    try {
+      await writeJsonExclusive(path, item);
+      return { id, path };
+    } catch (e) {
+      if (e && e.code === 'EEXIST') continue;
+      throw e;
+    }
+  }
+  const err = new Error(
+    `pa work create: gave up after ${MAX_ALLOCATE_RETRIES} EEXIST retries from base NNN ${baseN + 1} in ${dateStr} author=${author}`,
+  );
+  err.exitCode = 2;
+  throw err;
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stravica-ai/digital-operator-pa",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "Digital Operator PA \u2014 single-bundled public package surface (bins + library) for the platform.",
   "type": "module",
   "main": "./index.mjs",