@deksden-com/dd-flow-cli 0.9.0-beta.152 → 0.9.0-beta.156

package/dist/harness-runtime/lib/zcode-native-hook-ownership.mjs

@@ -0,0 +1,109 @@
+// This map is optional evidence, not a replacement for the ordinary hook.
+// A turn becomes authoritative only after the bridge has matched the native
+// inputId it supplied on session/send and echoed by native turn.started.
+export class ZcodeNativeHookOwnership {
+  constructor() { this.turns = new Map(); this.invalidTurns = new Set(); this.requests = new Map(); this.observers = new Map(); this.managedSessions = new Set(); this.buffer = new Map(); this.hooks = new Map(); this.waiters = new Map(); }
+  key(...values) { return JSON.stringify(values); }
+  signature(message) { const update = message.params.update; return this.key(update.toolCallId, update.rawInput, update._meta?.zcodeRuntime); }
+  register(operationId, observer, sessionId) { if (operationId && observer) { this.observers.set(operationId, observer); if (typeof sessionId === 'string' && sessionId) this.managedSessions.add(sessionId); } }
+  isManaged(sessionId, pending) { return this.managedSessions.has(sessionId) || [...pending.values()].some(request => request.method === 'session/prompt' && request.sessionId === sessionId && request.nativeHookOwner); }
+  bind(params, pending) {
+    const { sessionId, requestId, nativeTurnId } = params ?? {};
+    const owner = pending?.nativeHookOwner;
+    if (!owner || pending.method !== 'session/prompt' || pending.id !== requestId || pending.sessionId !== sessionId
+      || typeof nativeTurnId !== 'string' || !nativeTurnId || !owner.operationId || !owner.rootProviderSessionId || !owner.valid()) return [];
+    const turnKey = this.key(sessionId, nativeTurnId), requestKey = this.key(sessionId, requestId);
+    if (this.invalidTurns.has(turnKey)) return [];
+    const priorTurn = this.turns.get(turnKey), priorRequest = this.requests.get(requestKey);
+    if (priorTurn && priorTurn.requestKey !== requestKey || priorRequest && priorRequest !== turnKey) {
+      this.invalidTurns.add(turnKey);
+      if (priorRequest && priorRequest !== 'conflict') this.invalidTurns.add(priorRequest);
+      if (priorTurn) priorTurn.invalid = true;
+      if (priorRequest && this.turns.has(priorRequest)) this.turns.get(priorRequest).invalid = true;
+      this.requests.set(requestKey, 'conflict'); this.buffer.delete(turnKey); return [];
+    }
+    if (!priorTurn) this.turns.set(turnKey, { requestKey, owner, tools: new Map(), waiting: [], seen: new Set(), invalid: false });
+    this.requests.set(requestKey, turnKey); this.managedSessions.add(sessionId); owner.retainNativeHooks = true;
+    const buffered = this.buffer.get(turnKey) ?? new Map(); this.buffer.delete(turnKey);
+    return [...buffered.values()].flatMap(message => this.observeBound(message, this.turns.get(turnKey)));
+  }
+  observe(message, mayBuffer, managed) {
+    const native = message?.params?.update?._meta?.zcodeRuntime;
+    if (message?.method !== 'session/update' || message.params.update?.sessionUpdate !== 'tool_call') return null;
+    if (!Object.hasOwn(native ?? {}, 'nativeTurnId')) return managed && (native?.source === 'subagent' || native?.childSessionId) ? [] : null;
+    const { sessionId } = message.params, { nativeTurnId } = native;
+    if (typeof sessionId !== 'string' || typeof nativeTurnId !== 'string' || !nativeTurnId) return managed ? [] : null;
+    const key = this.key(sessionId, nativeTurnId), turn = this.turns.get(key);
+    if (this.invalidTurns.has(key)) return [];
+    if (turn) return this.observeBound(message, turn);
+    if (!managed) return null;
+    if (mayBuffer) { const buffer = this.buffer.get(key) ?? new Map(); buffer.set(this.signature(message), message); this.buffer.set(key, buffer); }
+    return [];
+  }
+  discardUnbound(sessionId) {
+    for (const key of this.buffer.keys()) if (JSON.parse(key)[0] === sessionId) this.buffer.delete(key);
+  }
+  isCurrent(message, pending) {
+    const native = message?.params?.update?._meta?.zcodeRuntime;
+    if (!Object.hasOwn(native ?? {}, 'nativeTurnId')) return !(native?.source === 'subagent' || native?.childSessionId) || !this.isManaged(message.params.sessionId, pending);
+    const turn = this.turns.get(this.key(message.params.sessionId, native.nativeTurnId));
+    if (!turn) return !this.isManaged(message.params.sessionId, pending);
+    return Boolean(turn && !turn.invalid && turn.owner.valid() && [...pending.values()].some(request =>
+      request.method === 'session/prompt' && request.sessionId === message.params.sessionId && request.nativeHookOwner === turn.owner));
+  }
+  observeBound(message, turn) {
+    if (turn.invalid || !turn.owner.valid()) return [];
+    const signature = this.signature(message); if (turn.seen.has(signature)) return [];
+    turn.seen.add(signature);
+    // An unresolved native parent may arrive after the root turn returned;
+    // keep these exact, deduplicated facts only for this daemon lifetime.
+    turn.waiting.push(message);
+    const routed = [];
+    let progress = true;
+    while (progress) {
+      progress = false;
+      for (let i = 0; i < turn.waiting.length; i++) {
+        const event = turn.waiting[i], update = event.params.update, native = update._meta?.zcodeRuntime ?? {};
+        const tool = update.toolCallId, child = native.childSessionId;
+        if (typeof tool !== 'string' || !tool) { turn.waiting.splice(i--, 1); continue; }
+        if (native.source === 'subagent' && !child) { turn.waiting.splice(i--, 1); continue; }
+        const parent = child ? turn.tools.get(native.parentToolCallId) : null;
+        if (child && !parent) continue;
+        const session = child || turn.owner.rootProviderSessionId;
+        if (typeof session !== 'string' || !session || child && session === parent) { turn.waiting.splice(i--, 1); continue; }
+        const existing = turn.tools.get(tool);
+        if (existing && existing !== session) { turn.invalid = true; return []; }
+        turn.tools.set(tool, session); turn.waiting.splice(i--, 1); progress = true;
+        const command = update.rawInput?.command ?? update.rawInput?.cmd;
+        if (child && typeof native.childToolCallId === 'string' && native.childToolCallId && typeof command === 'string') {
+          const key = this.key(session, native.childToolCallId), fact = { owner: turn.owner, root: turn.owner.rootProviderSessionId, parent, session, tool: native.childToolCallId, command, message: event, turn };
+          const prior = this.hooks.get(key);
+          if (prior && (prior.owner !== fact.owner || prior.parent !== parent || prior.command !== command)) { this.hooks.set(key, null); turn.invalid = true; turn.waiting.length = 0; return []; }
+          else if (prior === undefined) this.hooks.set(key, fact);
+          for (const wake of this.waiters.get(key) ?? []) wake();
+        }
+        const observer = this.observers.get(turn.owner.operationId);
+        if (observer) routed.push({ message: event, observer, owner: turn.owner });
+      }
+    }
+    return routed;
+  }
+  fact(session, tool, command) {
+    const value = this.hooks.get(this.key(session, tool));
+    return value && !value.turn.invalid && value.owner.valid() && value.command === command ? value : null;
+  }
+  async wait(session, tool, command, deadlineAt) {
+    if (this.fact(session, tool, command)) return;
+    const remaining = deadlineAt - Date.now();
+    if (!Number.isSafeInteger(deadlineAt) || remaining <= 0 || remaining > 30_000) return;
+    const waitMs = Math.floor(remaining / 3); if (!waitMs) return;
+    const key = this.key(session, tool);
+    await new Promise(resolve => {
+      const waiters = this.waiters.get(key) ?? new Set();
+      const wake = () => { if (!this.fact(session, tool, command) && Date.now() < until) return; clearTimeout(timer); waiters.delete(wake); if (!waiters.size) this.waiters.delete(key); resolve(); };
+      const until = Date.now() + waitMs, timer = setTimeout(() => { waiters.delete(wake); if (!waiters.size) this.waiters.delete(key); resolve(); }, waitMs);
+      waiters.add(wake); this.waiters.set(key, waiters);
+      wake();
+    });
+  }
+}

package/dist/schemas/code-work-result.schema.json

@@ -11,6 +11,7 @@
     "evidence": {"type": "array", "items": {"type": "object", "additionalProperties": false, "required": ["obligation_ref", "refs"], "properties": {"obligation_ref": {"type": "string", "minLength": 1}, "refs": {"type": "array", "uniqueItems": true, "items": {"type": "string", "minLength": 1}}}}},
     "deviations": {"type": "array", "items": {"type": "string", "minLength": 1}},
     "blockers": {"type": "array", "items": {"type": "string", "minLength": 1}},
-    "resolutions": {"type": "array", "uniqueItems": true, "items": {"type": "object", "additionalProperties": false, "required": ["finding_ref", "summary", "evidence_refs"], "properties": {"finding_ref": {"type": "string", "minLength": 1}, "summary": {"type": "string", "minLength": 1}, "evidence_refs": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "minLength": 1}}}}}
+    "resolutions": {"type": "array", "uniqueItems": true, "items": {"type": "object", "additionalProperties": false, "required": ["finding_ref", "summary", "evidence_refs"], "properties": {"finding_ref": {"type": "string", "minLength": 1}, "disposition": {"enum": ["fixed", "already_satisfied", "disputed"]}, "summary": {"type": "string", "minLength": 1}, "evidence_refs": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "minLength": 1}}}}},
+    "document_resolutions": {"type": "array", "uniqueItems": true, "items": {"type": "object", "additionalProperties": false, "required": ["path", "disposition", "summary", "evidence_refs"], "properties": {"path": {"type": "string", "minLength": 1}, "disposition": {"const": "already_satisfied"}, "summary": {"type": "string", "minLength": 1}, "evidence_refs": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "minLength": 1}}}}}
   }
 }

package/dist/schemas/delivery-stage-result.schema.json

@@ -0,0 +1,286 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "dd-flow/delivery-stage-result@1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_id",
+    "flow_id",
+    "run_id",
+    "stage",
+    "input_sha256",
+    "user_inputs_sha256",
+    "summary",
+    "predecessors",
+    "details"
+  ],
+  "properties": {
+    "schema_id": {
+      "const": "dd-flow/delivery-stage-result@1"
+    },
+    "flow_id": {
+      "enum": [
+        "release",
+        "deploy",
+        "publish"
+      ]
+    },
+    "run_id": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 16384,
+      "pattern": "^[^\\u0000]+$"
+    },
+    "stage": {
+      "enum": [
+        "preflight",
+        "version-decision",
+        "target-decision",
+        "prepare",
+        "verify",
+        "publish",
+        "deploy",
+        "finish"
+      ]
+    },
+    "input_sha256": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "user_inputs_sha256": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "summary": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 16384,
+      "pattern": "^[^\\u0000]+$"
+    },
+    "predecessors": {
+      "type": "array",
+      "maxItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "stage",
+          "path",
+          "sha256"
+        ],
+        "properties": {
+          "stage": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 16384,
+            "pattern": "^[^\\u0000]+$"
+          },
+          "path": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 4096,
+            "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.?(?:/|$))[^\\\\\\u0000]+$"
+          },
+          "sha256": {
+            "type": "string",
+            "pattern": "^[a-f0-9]{64}$"
+          }
+        }
+      }
+    },
+    "details": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "decision",
+        "artifact",
+        "delivery_scope_sha256",
+        "intent_sha256",
+        "readback_sha256",
+        "verification_sha256",
+        "limitations",
+        "rollback"
+      ],
+      "properties": {
+        "decision": {
+          "anyOf": [
+            {
+              "type": "null"
+            },
+            {
+              "type": "object",
+              "additionalProperties": false,
+              "required": [
+                "operation_id",
+                "version",
+                "binding",
+                "policy"
+              ],
+              "properties": {
+                "operation_id": {
+                  "type": "string",
+                  "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"
+                },
+                "version": {
+                  "type": "string",
+                  "minLength": 1,
+                  "maxLength": 16384,
+                  "pattern": "^[^\\u0000]+$"
+                },
+                "binding": {
+                  "type": "object"
+                },
+                "policy": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "required": ["path", "sha256"],
+                  "properties": {
+                    "path": {"type": "string", "minLength": 1, "maxLength": 4096},
+                    "sha256": {"type": "string", "pattern": "^[a-f0-9]{64}$"}
+                  }
+                },
+                "rollback": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "required": ["strategy", "procedure_ref", "reason"],
+                  "properties": {
+                    "strategy": {"enum": ["rollback", "roll_forward", "operator_handoff"]},
+                    "procedure_ref": {"anyOf": [{"type": "null"}, {"type": "string", "minLength": 1, "maxLength": 4096, "pattern": "^[^\\u0000]+$"}]},
+                    "reason": {"type": "string", "minLength": 1, "maxLength": 4096, "pattern": "^[^\\u0000]+$"}
+                  },
+                  "allOf": [{
+                    "if": {"properties": {"strategy": {"enum": ["rollback", "roll_forward"]}}},
+                    "then": {"properties": {"procedure_ref": {"type": "string", "minLength": 1}}}
+                  }]
+                }
+              }
+            }
+          ]
+        },
+        "artifact": {
+          "anyOf": [
+            {
+              "type": "null"
+            },
+            {
+              "type": "object",
+              "additionalProperties": false,
+              "required": [
+                "path",
+                "subject_ref",
+                "version",
+                "sha256"
+              ],
+              "properties": {
+                "path": {
+                  "type": "string",
+                  "minLength": 1,
+                  "maxLength": 4096,
+                  "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.?(?:/|$))[^\\\\\\u0000]+$"
+                },
+                "subject_ref": {
+                  "type": "string",
+                  "minLength": 1,
+                  "maxLength": 16384,
+                  "pattern": "^[^\\u0000]+$"
+                },
+                "version": {
+                  "type": "string",
+                  "minLength": 1,
+                  "maxLength": 16384,
+                  "pattern": "^[^\\u0000]+$"
+                },
+                "sha256": {
+                  "type": "string",
+                  "pattern": "^[a-f0-9]{64}$"
+                }
+              }
+            }
+          ]
+        },
+        "delivery_scope_sha256": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[a-f0-9]{64}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "intent_sha256": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[a-f0-9]{64}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "readback_sha256": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[a-f0-9]{64}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "verification_sha256": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[a-f0-9]{64}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "rollback": {
+          "anyOf": [
+            {"type": "null"},
+            {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["strategy", "status", "reason", "reference"],
+              "properties": {
+                "strategy": {"enum": ["rollback", "roll_forward", "operator_handoff"]},
+                "status": {"enum": ["not_needed", "required", "completed", "failed", "unknown"]},
+                "reason": {"type": "string", "minLength": 1, "maxLength": 4096, "pattern": "^[^\\u0000]+$"},
+                "reference": {
+                  "anyOf": [
+                    {"type": "null"},
+                    {
+                      "type": "object", "additionalProperties": false, "required": ["kind", "id"],
+                      "properties": {
+                        "kind": {"type": "string", "minLength": 1, "maxLength": 4096, "pattern": "^[^\\u0000]+$"},
+                        "id": {"type": "string", "minLength": 1, "maxLength": 4096, "pattern": "^[^\\u0000]+$"}
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        },
+        "limitations": {
+          "type": "array",
+          "maxItems": 4096,
+          "uniqueItems": true,
+          "items": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 16384,
+            "pattern": "^[^\\u0000]+$"
+          }
+        }
+      }
+    }
+  }
+}