@khoavu882/doflow 2.0.0-beta.4 → 2.0.0-beta.5

package/src/runtime/task-state.js

@@ -117,6 +117,43 @@ function acquireLock(fsImpl     , file        )             {
     + 'If no other session is running, the lock is leftover from a crash younger than its stale timeout; retry shortly.');
 }
 
+/**
+ * Takes the cross-process lock for one state file with a bounded wait.
+ * Makes 1 try plus `retries` retries (default 3) separated by `waitMs` (default 5).
+ * Throws an Error('store-locked') after one try plus retries.
+ * @param {Object} fsImpl
+ * @param {string} file
+ * @param {Object} [options]
+ * @param {number} [options.retries=3]
+ * @param {number} [options.waitMs=5]
+ * @returns {() => void} release function
+ */
+function boundedAcquire(
+  fsImpl     ,
+  file        ,
+  options   
+                     
+                    
+                                   
+                                                                          
+    = {}
+)             {
+  const retries = options?.retries ?? 3;
+  const waitMs = options?.waitMs ?? 5;
+  const sleepFn = options?.sleepFn ?? sleep;
+  const tryAcquire = options?.tryAcquireLockFn ?? tryAcquireLock;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    const release = tryAcquire(fsImpl, file);
+    if (release) return release;
+    if (attempt < retries && waitMs > 0) {
+      sleepFn(waitMs);
+    }
+  }
+  const error = new Error('store-locked');
+  (error       ).code = 'store-locked';
+  throw error;
+}
+
 /**
  * Reads and validates one task-state file. Returns null when the file does not exist.
  * @param {Object} fsImpl
@@ -129,13 +166,17 @@ function readTaskState(fsImpl     , file        )      {
   try {
     data = JSON.parse(fsImpl.readFileSync(file, 'utf8'));
   } catch (error     ) {
-    throw new Error(`Failed to load state file '${file}': ${error.message}. The write path is atomic `
+    const failure      = new Error(`Failed to load state file '${file}': ${error.message}. The write path is atomic `
       + '(tmp + rename), so a torn file means outside interference; recover it from version control '
       + 'or move it aside and re-record the task\'s items.');
+    failure.code = 'store-unreadable';
+    throw failure;
   }
   if (data && typeof data === 'object' && data.version !== undefined && data.version !== SCHEMA_VERSION) {
-    throw new Error(`State file '${file}' has schema version ${data.version}; this runtime reads version ${SCHEMA_VERSION}. `
+    const failure      = new Error(`State file '${file}' has schema version ${data.version}; this runtime reads version ${SCHEMA_VERSION}. `
       + 'Refusing to guess at its shape — upgrade the runtime or migrate the file.');
+    failure.code = 'store-unreadable';
+    throw failure;
   }
   return data;
 }
@@ -151,16 +192,32 @@ function readTaskState(fsImpl     , file        )      {
  *   return the complete new payload (without `version`/`revision`, which are stamped here)
  * @param {() => void} [options.prepare] called INSIDE the lock before the file is read, for a store
  *   that must inspect or set aside what is there under the same exclusion as the write
- * @returns {string} the file path written
+ * @param {(fsImpl: Object, file: string) => () => void} [options.acquire] optional lock acquirer
+ *   defaulting to acquireLock
+ * @returns {string|null} the file path written, or null when build declines a write
  */
-function updateTaskState({ fsImpl, file, build, prepare }                                                                                )         {
+function updateTaskState({
+  fsImpl,
+  file,
+  build,
+  prepare,
+  acquire = acquireLock,
+}   
+              
+               
+                            
+                       
+                                                      
+ )                {
   fsImpl.mkdirSync(path.dirname(file), { recursive: true });
-  const release = acquireLock(fsImpl, file);
+  const release = acquire(fsImpl, file);
   try {
     if (prepare) prepare();
     const disk = readTaskState(fsImpl, file);
+    const built = build(disk);
+    if (built === null) return null;
     const payload = {
-      ...build(disk),
+      ...built,
       version: SCHEMA_VERSION,
       revision: (disk && Number.isInteger(disk.revision) ? disk.revision : 0) + 1,
     };
@@ -173,4 +230,12 @@ function updateTaskState({ fsImpl, file, build, prepare }
   }
 }
 
-module.exports = { acquireLock, tryAcquireLock, updateTaskState, readTaskState, mergeRecords, SCHEMA_VERSION };
+module.exports = {
+  acquireLock,
+  tryAcquireLock,
+  boundedAcquire,
+  updateTaskState,
+  readTaskState,
+  mergeRecords,
+  SCHEMA_VERSION,
+};

package/core/.antigravity-plugin/hooks.json

@@ -1,39 +0,0 @@
-{
-  "description": "DoFlow lifecycle hooks for Google Antigravity (IDE & CLI). Uses stdin/stdout JSON protocol for real-time gating.",
-  "hooks": {
-    "SessionStart": [
-      {
-        "type": "command",
-        "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/session-start.sh\""
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "^(run_command|replace_file_content|write_to_file|multi_replace_file_content)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$DOFLOW_PROJECT_DIR/.doflow/scripts/stream-hook-runner.js\""
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "^(replace_file_content|write_to_file|multi_replace_file_content)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/post-edit-lint.sh\""
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "type": "command",
-        "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/stop-check.sh\""
-      }
-    ]
-  }
-}

package/core/harnesses/shared/hooks/adapters/arg-fields.js

@@ -1,19 +0,0 @@
-'use strict';
-
-/**
- * Shared toolCall.args field-name lookup for the toolCall/args envelope adapters
- * (antigravity.js, gemini.js's fallback path) both read when mapping to canonical
- * file_path/command. Extracted because both adapters carried an identical copy.
- */
-
-const FILE_PATH_ARG_FIELDS = ['AbsolutePath', 'TargetFile', 'Path', 'file_path', 'path'];
-const COMMAND_ARG_FIELDS = ['CommandLine', 'command'];
-
-function firstArgField(args, fields) {
-  for (const field of fields) {
-    if (args && args[field]) return args[field];
-  }
-  return '';
-}
-
-module.exports = { FILE_PATH_ARG_FIELDS, COMMAND_ARG_FIELDS, firstArgField };

package/core/harnesses/shared/hooks/adapters/gemini.js

@@ -1,114 +0,0 @@
-'use strict';
-
-/**
- * Gemini CLI payload/decision adapter for the Cross-Harness Hook Runner (design.md C2's
- * Payload Adapter / Decision Adapter seam, D2).
- *
- * Gemini's own native contract — evidenced by core/harnesses/gemini/hooks/*.sh and
- * core/harnesses/gemini/hooks/hooks.json, all currently invoked directly by bash rather than
- * through this runner — already speaks field names close to Claude/Codex/Kiro's, NOT
- * Antigravity's toolCall/args envelope:
- *
- *   SessionStart           : stdin  { session_id, cwd }                          (session-start.sh)
- *   BeforeTool (~PreToolUse): stdin  { tool_name, tool_input: { file_path, command } }
- *                             stdout { decision: "allow"|"deny", reason } — TOP-LEVEL, not
- *                             nested under hookSpecificOutput.permissionDecision like
- *                             Claude/Codex (confirmed in gemini/hooks/pre-bash-guard.sh's header).
- *   AfterTool (~PostToolUse): stdin { tool_name, tool_input: { file_path }, session_id }
- *                             (post-edit-lint.sh) — stdout {} (ack; no Phase A policy owns this
- *                             event, post-edit-lint.sh's collector role is out of FR-001's scope)
- *   Stop                    : NOT a documented Gemini lifecycle event — gemini/hooks/
- *                             post-edit-lint.sh's own comment states "Gemini has no
- *                             Stop-equivalent event," and no stop-check.sh ships under
- *                             gemini/hooks/ today. Handled defensively below (same field-name
- *                             union stop-check.sh itself accepts) in case a future Gemini
- *                             version adds one, or in case core/harnesses/shared/hooks/hooks.json's
- *                             existing (currently dangling) Stop entry is corrected to a real target.
- *
- * NFR-002 note: core/harnesses/shared/hooks/hooks.json has historically routed PreToolUse through
- * this runner using Antigravity's { toolCall: { name, args } } envelope — inherited from this
- * runner's original Antigravity-only design (see the runner's own prior header comment), not
- * verified against Gemini's own documented schema above. toCanonical() below reads the
- * tool_name/tool_input shape first (Gemini's own evidenced contract) and falls back to the
- * toolCall envelope only if that shape isn't present, so this adapter is correct once that
- * wiring is corrected without silently breaking before it is.
- */
-
-const { FILE_PATH_ARG_FIELDS, COMMAND_ARG_FIELDS, firstArgField } = require('./arg-fields');
-
-function toCanonical(event, payload) {
-  const safePayload = payload && typeof payload === 'object' ? payload : {};
-
-  switch (event) {
-    case 'SessionStart':
-      return { session_id: safePayload.session_id || '', cwd: safePayload.cwd || '' };
-
-    case 'PreToolUse': {
-      if (safePayload.tool_name !== undefined || safePayload.tool_input !== undefined) {
-        const toolInput = safePayload.tool_input || {};
-        return {
-          tool_name: safePayload.tool_name || '',
-          tool_input: {
-            file_path: toolInput.file_path || '',
-            command: toolInput.command || '',
-          },
-        };
-      }
-      // Defensive fallback: Antigravity-shaped envelope (see header note).
-      const toolCall = safePayload.toolCall || {};
-      const args = toolCall.args || {};
-      return {
-        tool_name: toolCall.name || '',
-        tool_input: {
-          file_path: firstArgField(args, FILE_PATH_ARG_FIELDS),
-          command: firstArgField(args, COMMAND_ARG_FIELDS),
-        },
-      };
-    }
-
-    case 'PostToolUse':
-      return {
-        tool_name: safePayload.tool_name || '',
-        session_id: safePayload.session_id || '',
-        tool_input: { file_path: (safePayload.tool_input && safePayload.tool_input.file_path) || '' },
-      };
-
-    case 'Stop':
-      return {
-        session_id: safePayload.session_id || '',
-        transcript_path: safePayload.transcript_path || safePayload.transcriptPath || '',
-      };
-
-    default:
-      return safePayload;
-  }
-}
-
-function toNative(event, decision) {
-  const safeDecision = decision || { decision: 'allow' };
-
-  switch (event) {
-    case 'PreToolUse':
-      if (safeDecision.decision === 'deny') {
-        return { decision: 'deny', reason: safeDecision.reason };
-      }
-      return { decision: 'allow' };
-
-    case 'PostToolUse':
-      return {};
-
-    case 'Stop':
-      if (safeDecision.decision === 'deny') {
-        return { decision: 'deny', reason: safeDecision.reason };
-      }
-      return { decision: 'allow' };
-
-    case 'SessionStart':
-      return {};
-
-    default:
-      return { decision: 'allow' };
-  }
-}
-
-module.exports = { toCanonical, toNative };

package/core/harnesses/shared/hooks/hooks.json

@@ -1,47 +0,0 @@
-{
-  "description": "DoFlow shared lifecycle hooks schema for Antigravity, Gemini, and Claude.",
-  "hooks": {
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/session-start.sh\""
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "^(run_command|run_shell_command|replace_file_content|write_to_file|multi_replace_file_content|edit_file|Edit|Write)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$DOFLOW_PROJECT_DIR/.doflow/scripts/stream-hook-runner.js\""
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "^(replace_file_content|write_to_file|multi_replace_file_content|edit_file|Edit|Write)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/post-edit-lint.sh\""
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/stop-check.sh\""
-          }
-        ]
-      }
-    ]
-  }
-}