@deksden-com/dd-flow-cli 0.7.0 → 0.8.0

package/dist/services/hooks.js

@@ -7,7 +7,7 @@ import { AppError } from "../shared/errors.js";
 import { parseJsonObject } from "../shared/json.js";
 import { ensureDir, resolveProjectRoot } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
-import { requireProjectByRoot } from "./projects.js";
+import { registerProject, requireProjectByRoot } from "./projects.js";
 import { activeFlowSessionsForProject, bindObservedFlowSession, flowSessionPayloadFromRegisterCommand, recordFlowSessionObservation } from "./sessions.js";
 const defaultProfileName = "default";
 const maxSanitizedSummaryLength = 1600;
@@ -269,14 +269,56 @@ export function handleCodexHook(context, input) {
     const sessionId = stringValue(payload.session_id);
     const turnId = stringValue(payload.turn_id);
     const toolName = stringValue(payload.tool_name) ?? toolNameFromPayload(payload);
-    const command = commandFromPayload(payload);
+    const command = lifecycleCommandFromPayload(payload);
     if (!command)
         return { ok: true, observed: false, reason: "non_bash_tool" };
+    const stageResume = /\bdd-flow\s+stage\s+resume\b/.test(command);
+    const stagePauseHeredoc = containsUnquotedHeredoc(command) && /\bdd-flow\s+stage\s+pause\b/.test(command);
+    const lifecycleShell = analyzeLifecycleShellCommand(command);
+    // Resume legitimately receives an answer through stdin. It is matched by
+    // immutable lifecycle arguments below; never reject or rewrite that pipe.
+    if (lifecycleShell.kind === "compound" && !stageResume && !stagePauseHeredoc) {
+        return {
+            ok: false,
+            observed: false,
+            reason: "compound_lifecycle_command",
+            message: "Run the dd-flow lifecycle invocation as the first technical action and as one standalone Bash command in this same Session.",
+            standalone_command: lifecycleShell.standaloneCommand,
+            hookSpecificOutput: {
+                hookEventName: "PreToolUse",
+                permissionDecision: "deny",
+                permissionDecisionReason: `dd-flow lifecycle commands must be standalone. Retry in this same Session: ${lifecycleShell.standaloneCommand}`
+            }
+        };
+    }
     const flowPayload = flowSessionPayloadFromRegisterCommand(command);
-    const bootstrapStageStart = /\bdd-flow\s+stage\s+start\b/.test(command) && /(?:^|\s)--bootstrap(?:\s|$)/.test(command);
-    if (!flowPayload && !bootstrapStageStart)
+    const stageStart = /\bdd-flow\s+stage\s+start\b/.test(command);
+    const workStart = /\bdd-flow\s+work\s+start\b/.test(command);
+    const bootstrapStageStart = stageStart && /(?:^|\s)--bootstrap(?:\s|$)/.test(command);
+    if (!flowPayload && !stageStart && !stageResume && !workStart)
         return { ok: true, observed: false, reason: "event_not_participating", event: eventName };
-    const project = projectForHook(context, input.projectRoot, stringValue(payload.cwd));
+    const commandProjectRoot = optionFromCommand(command, "project-root");
+    const stageName = stageStart ? optionFromCommand(command, "stage") : undefined;
+    const resumeStageName = stageResume ? optionFromCommand(command, "stage") : undefined;
+    const stageRunId = stageStart && !bootstrapStageStart ? positionalFromCommand(command, "dd-flow stage start") : undefined;
+    const resumeRunId = stageResume ? positionalFromCommand(command, "dd-flow stage resume") : undefined;
+    const resumeWorkId = stageResume ? optionFromCommand(command, "work") : undefined;
+    const workId = workStart ? positionalFromCommand(command, "dd-flow work start") : undefined;
+    const contextSha256 = optionFromCommand(command, "context-sha256") ?? undefined;
+    const matchKey = bootstrapStageStart && commandProjectRoot ? bootstrapMatchKey({
+        projectRoot: commandProjectRoot,
+        subject: optionFromCommand(command, "subject") ?? optionFromCommand(command, "slug") ?? "specify",
+        intakeMode: contextSha256 ? "context" : /(?:^|\s)--intake-stdin(?:\s|$)/.test(command) ? "stdin" : "file",
+        ...(contextSha256 ? { contextSha256 } : {})
+    }) : stageStart && stageRunId && stageName && commandProjectRoot ? stageStartMatchKey(stageRunId, stageName, commandProjectRoot, contextSha256)
+        : stageResume && resumeRunId && resumeStageName && resumeWorkId && commandProjectRoot ? stageResumeMatchKey(resumeRunId, resumeStageName, resumeWorkId, commandProjectRoot)
+            : workStart && workId && commandProjectRoot ? workStartMatchKey(workId, commandProjectRoot) : null;
+    // A bootstrap stage is the first stateful command for a new materialized project.
+    // Its PreToolUse event arrives before stage start can register that project.
+    if (bootstrapStageStart && commandProjectRoot) {
+        registerProject(context, { root: commandProjectRoot });
+    }
+    const project = projectForHook(context, input.projectRoot ?? commandProjectRoot, stringValue(payload.cwd));
     if (!project)
         return { ok: true, observed: false, reason: "unrelated_cwd" };
     const binding = sessionId ? upsertSessionBindingFromPayload(context, project, sessionId, payload) : undefined;
@@ -289,13 +331,20 @@ export function handleCodexHook(context, input) {
     const inserted = recordHookEvent(context, {
         projectId: project.id,
         protocolId,
+        harness: "codex-desktop",
+        providerSessionId: sessionId ?? null,
+        parentSessionId: null,
         sessionId: effectiveSessionId,
+        agentId: stringValue(payload.agent_id) ?? null,
         turnId: turnId ?? null,
         eventName,
         toolName: toolName ?? null,
         status: "observed",
         payload,
-        eventKey
+        eventKey,
+        matchKey,
+        transcriptPath: binding?.transcript_path ?? null,
+        cwd: stringValue(payload.cwd) ?? null
     });
     if (effectiveSessionId) {
         recordFlowSessionObservation(context, {
@@ -315,21 +364,649 @@ export function handleCodexHook(context, input) {
         event_key: eventKey,
         session_id: effectiveSessionId,
         protocol_id: protocolId,
-        ...(sessionId
+        ...(sessionId && (flowPayload || stageStart || stageResume || workStart)
             ? {
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
                     permissionDecision: "allow",
-                    updatedInput: { command: commandWithSessionId(command, sessionId) }
+                    updatedInput: { command: commandWithHookEvent(command, eventKey) }
                 }
             }
             : {})
     };
 }
-function commandWithSessionId(command, sessionId) {
-    if (/(?:^|\s)--session-id(?:=|\s)/.test(command))
+/** Convert a zcode-acp Bash tool notification into the same trusted lifecycle receipt used by Codex hooks. */
+export function handleZcodeEvent(context, input) {
+    const notification = parseJsonObject(input.stdin || "{}", "zcode ACP notification");
+    if (notification.method !== "session/update")
+        return { ok: true, observed: false, reason: "event_not_participating" };
+    const params = objectRecord(notification.params);
+    const update = objectRecord(params.update);
+    if (update.sessionUpdate !== "tool_call")
+        return { ok: true, observed: false, reason: "event_not_participating" };
+    const updateMeta = objectRecord(update._meta);
+    const claudeCode = objectRecord(updateMeta.claudeCode);
+    const runtime = objectRecord(updateMeta.zcodeRuntime);
+    const toolName = stringValue(claudeCode.toolName) ?? stringValue(update.kind);
+    const rawInput = objectRecord(update.rawInput);
+    const command = stringValue(rawInput.command) ?? stringValue(rawInput.cmd);
+    if (!command || (toolName && toolName !== "Bash" && toolName !== "bash" && update.kind !== "execute")) {
+        return { ok: true, observed: false, reason: "non_bash_tool" };
+    }
+    const stageResume = /\bdd-flow\s+stage\s+resume\b/.test(command);
+    const stagePauseHeredoc = containsUnquotedHeredoc(command) && /\bdd-flow\s+stage\s+pause\b/.test(command);
+    const lifecycleShell = analyzeLifecycleShellCommand(command, true);
+    if (lifecycleShell.kind === "compound" && !stageResume && !stagePauseHeredoc) {
+        throw new AppError("compound_lifecycle_command", "dd-flow lifecycle commands must be a standalone ZCode Bash tool call", 1, {
+            standalone_command: lifecycleShell.standaloneCommand
+        });
+    }
+    const flowPayload = flowSessionPayloadFromRegisterCommand(command);
+    const stageStart = /\bdd-flow\s+stage\s+start\b/.test(command);
+    const workStart = /\bdd-flow\s+work\s+start\b/.test(command);
+    const bootstrapStageStart = stageStart && /(?:^|\s)--bootstrap(?:\s|$)/.test(command);
+    if (!flowPayload && !stageStart && !stageResume && !workStart) {
+        return { ok: true, observed: false, reason: "event_not_participating" };
+    }
+    const commandProjectRoot = optionFromCommand(command, "project-root");
+    const expectedRoot = resolveProjectRoot(input.projectRoot);
+    if (commandProjectRoot && resolveProjectRoot(commandProjectRoot) !== expectedRoot) {
+        throw new AppError("project_mismatch", "ZCode lifecycle command project root does not match the controlled workspace", 1, {
+            expected: expectedRoot,
+            actual: commandProjectRoot
+        });
+    }
+    const stageName = stageStart ? optionFromCommand(command, "stage") : undefined;
+    const resumeStageName = stageResume ? optionFromCommand(command, "stage") : undefined;
+    const stageRunId = stageStart && !bootstrapStageStart ? positionalFromCommand(command, "dd-flow stage start") : undefined;
+    const resumeRunId = stageResume ? positionalFromCommand(command, "dd-flow stage resume") : undefined;
+    const resumeWorkId = stageResume ? optionFromCommand(command, "work") : undefined;
+    const workId = workStart ? positionalFromCommand(command, "dd-flow work start") : undefined;
+    const contextSha256 = optionFromCommand(command, "context-sha256") ?? undefined;
+    const matchKey = bootstrapStageStart ? bootstrapMatchKey({
+        projectRoot: expectedRoot,
+        subject: optionFromCommand(command, "subject") ?? optionFromCommand(command, "slug") ?? "specify",
+        intakeMode: contextSha256 ? "context" : /(?:^|\s)--intake-stdin(?:\s|$)/.test(command) ? "stdin" : "file",
+        ...(contextSha256 ? { contextSha256 } : {})
+    }) : stageStart && stageRunId && stageName ? stageStartMatchKey(stageRunId, stageName, expectedRoot, contextSha256)
+        : stageResume && resumeRunId && resumeStageName && resumeWorkId ? stageResumeMatchKey(resumeRunId, resumeStageName, resumeWorkId, expectedRoot)
+            : workStart && workId ? workStartMatchKey(workId, expectedRoot) : null;
+    if (bootstrapStageStart)
+        registerProject(context, { root: expectedRoot });
+    const project = requireProjectByRoot(context, expectedRoot);
+    const envelopeMeta = objectRecord(notification._meta);
+    const ddZcode = objectRecord(envelopeMeta.ddZcode);
+    const observedProfile = objectRecord(ddZcode.observedProfile);
+    const rootProviderSessionId = stringValue(ddZcode.rootProviderSessionId) ?? stringValue(params.sessionId);
+    const daemonId = stringValue(ddZcode.daemonId);
+    if (!rootProviderSessionId)
+        throw new AppError("zcode_identity_missing", "ZCode ACP event has no root provider Session ID", 1);
+    const childProviderSessionId = stringValue(runtime.childSessionId);
+    const providerSessionId = childProviderSessionId ?? rootProviderSessionId;
+    const sessionId = `zcode-acp:${providerSessionId}`;
+    const parentSessionId = childProviderSessionId ? `zcode-acp:${rootProviderSessionId}` : null;
+    const agentId = stringValue(runtime.agentId);
+    const observedSession = flowPayload ? bindObservedFlowSession(context, project, {
+        ...flowPayload,
+        harness: "zcode-acp",
+        provider_session_id: providerSessionId,
+        agent_id: agentId ?? null,
+        parent_session_id: parentSessionId
+    }, sessionId) : undefined;
+    const eventKey = stringValue(update.toolCallId) ?? crypto.createHash("sha256").update(JSON.stringify({
+        harness: "zcode-acp", providerSessionId, command
+    })).digest("hex");
+    const payload = {
+        session_id: providerSessionId,
+        agent_id: agentId,
+        cwd: expectedRoot,
+        tool_name: toolName ?? "Bash",
+        tool_input: rawInput,
+        command,
+        provider: stringValue(observedProfile.provider),
+        model: stringValue(observedProfile.model),
+        reasoning: stringValue(observedProfile.reasoning),
+        mode: stringValue(observedProfile.mode),
+        agent_type: stringValue(runtime.source)
+    };
+    const inserted = recordHookEvent(context, {
+        projectId: project.id,
+        protocolId: observedSession?.protocol_id ?? null,
+        harness: "zcode-acp",
+        providerSessionId,
+        parentSessionId,
+        daemonId: daemonId ?? null,
+        sessionId,
+        agentId: agentId ?? null,
+        turnId: null,
+        eventName: "PreToolUse",
+        toolName: toolName ?? "Bash",
+        status: "observed",
+        payload,
+        eventKey,
+        matchKey,
+        transcriptPath: null,
+        cwd: expectedRoot
+    });
+    recordFlowSessionObservation(context, {
+        projectId: project.id,
+        sessionId,
+        runId: observedSession?.run_id ?? null,
+        protocolId: observedSession?.protocol_id ?? null,
+        cwd: expectedRoot,
+        toolName: toolName ?? "Bash",
+        eventKey
+    });
+    return {
+        ok: true,
+        observed: inserted,
+        duplicate: !inserted,
+        event_key: eventKey,
+        harness: "zcode-acp",
+        session_id: sessionId,
+        provider_session_id: providerSessionId,
+        parent_session_id: parentSessionId,
+        daemon_id: daemonId ?? null
+    };
+}
+/** Convert a Grok Build PreToolUse hook into a trusted lifecycle receipt. */
+export function handleGrokEvent(context, input) {
+    const hook = parseJsonObject(input.stdin || "{}", "Grok Build hook event");
+    const eventName = stringValue(hook.hook_event_name) ?? stringValue(hook.hookEventName);
+    if (eventName && eventName !== "PreToolUse" && eventName !== "pre_tool_use") {
+        return { ok: true, observed: false, reason: "event_not_participating" };
+    }
+    const toolName = stringValue(hook.tool_name) ?? stringValue(hook.toolName);
+    const rawInput = objectRecord(hook.tool_input ?? hook.toolInput);
+    const command = stringValue(rawInput?.command) ?? stringValue(rawInput?.cmd) ?? stringValue(hook.command);
+    if (!command || (toolName && !["Bash", "bash", "run_terminal_command", "RunTerminalCommand"].includes(toolName))) {
+        return { ok: true, observed: false, reason: "non_bash_tool" };
+    }
+    const stageResume = /\bdd-flow\s+stage\s+resume\b/.test(command);
+    const stagePauseHeredoc = containsUnquotedHeredoc(command) && /\bdd-flow\s+stage\s+pause\b/.test(command);
+    const lifecycleShell = analyzeLifecycleShellCommand(command, true);
+    if (lifecycleShell.kind === "compound" && !stageResume && !stagePauseHeredoc) {
+        throw new AppError("compound_lifecycle_command", "dd-flow lifecycle commands must be a standalone Grok Build tool call", 1, {
+            standalone_command: lifecycleShell.standaloneCommand
+        });
+    }
+    const flowPayload = flowSessionPayloadFromRegisterCommand(command);
+    const stageStart = /\bdd-flow\s+stage\s+start\b/.test(command);
+    const workStart = /\bdd-flow\s+work\s+start\b/.test(command);
+    const bootstrapStageStart = stageStart && /(?:^|\s)--bootstrap(?:\s|$)/.test(command);
+    if (!flowPayload && !stageStart && !stageResume && !workStart)
+        return { ok: true, observed: false, reason: "event_not_participating" };
+    const commandProjectRoot = optionFromCommand(command, "project-root");
+    const expectedRoot = resolveProjectRoot(input.projectRoot);
+    if (commandProjectRoot && resolveProjectRoot(commandProjectRoot) !== expectedRoot) {
+        throw new AppError("project_mismatch", "Grok Build lifecycle command project root does not match the controlled workspace", 1, {
+            expected: expectedRoot, actual: commandProjectRoot
+        });
+    }
+    const stageName = stageStart ? optionFromCommand(command, "stage") : undefined;
+    const resumeStageName = stageResume ? optionFromCommand(command, "stage") : undefined;
+    const stageRunId = stageStart && !bootstrapStageStart ? positionalFromCommand(command, "dd-flow stage start") : undefined;
+    const resumeRunId = stageResume ? positionalFromCommand(command, "dd-flow stage resume") : undefined;
+    const resumeWorkId = stageResume ? optionFromCommand(command, "work") : undefined;
+    const workId = workStart ? positionalFromCommand(command, "dd-flow work start") : undefined;
+    const contextSha256 = optionFromCommand(command, "context-sha256") ?? undefined;
+    const matchKey = bootstrapStageStart ? bootstrapMatchKey({
+        projectRoot: expectedRoot,
+        subject: optionFromCommand(command, "subject") ?? optionFromCommand(command, "slug") ?? "specify",
+        intakeMode: contextSha256 ? "context" : /(?:^|\s)--intake-stdin(?:\s|$)/.test(command) ? "stdin" : "file",
+        ...(contextSha256 ? { contextSha256 } : {})
+    }) : stageStart && stageRunId && stageName ? stageStartMatchKey(stageRunId, stageName, expectedRoot, contextSha256)
+        : stageResume && resumeRunId && resumeStageName && resumeWorkId ? stageResumeMatchKey(resumeRunId, resumeStageName, resumeWorkId, expectedRoot)
+            : workStart && workId ? workStartMatchKey(workId, expectedRoot) : null;
+    if (bootstrapStageStart)
+        registerProject(context, { root: expectedRoot });
+    const project = requireProjectByRoot(context, expectedRoot);
+    const meta = objectRecord(hook._meta);
+    const ddGrok = objectRecord(meta.ddGrok);
+    const observedProfile = objectRecord(ddGrok.observedProfile);
+    const rootProviderSessionId = stringValue(ddGrok.rootProviderSessionId);
+    const providerSessionId = stringValue(hook.session_id) ?? stringValue(hook.sessionId);
+    if (!rootProviderSessionId || !providerSessionId)
+        throw new AppError("grok_identity_missing", "Grok Build hook has no trusted Session ID", 1);
+    const isChild = providerSessionId !== rootProviderSessionId;
+    const sessionId = `grok-acp:${providerSessionId}`;
+    const parentSessionId = isChild ? `grok-acp:${stringValue(ddGrok.parentProviderSessionId) ?? rootProviderSessionId}` : null;
+    const daemonId = stringValue(ddGrok.daemonId);
+    const agentId = stringValue(hook.agent_id) ?? stringValue(hook.agentId);
+    const observedSession = flowPayload ? bindObservedFlowSession(context, project, {
+        ...flowPayload, harness: "grok-acp", provider_session_id: providerSessionId, agent_id: agentId ?? null, parent_session_id: parentSessionId
+    }, sessionId) : undefined;
+    const eventKey = stringValue(hook.event_id) ?? stringValue(hook.eventId) ?? crypto.createHash("sha256").update(JSON.stringify({
+        harness: "grok-acp", providerSessionId, command, turn: hook.turn_id ?? hook.turnId ?? null
+    })).digest("hex");
+    const payload = {
+        ...hook, session_id: providerSessionId, agent_id: agentId, cwd: expectedRoot, tool_name: toolName ?? "Bash", tool_input: rawInput,
+        command, provider: stringValue(observedProfile.provider), model: stringValue(observedProfile.model), reasoning: stringValue(observedProfile.reasoning), mode: stringValue(observedProfile.mode), agent_type: stringValue(hook.subagent_type) ?? stringValue(hook.subagentType)
+    };
+    const inserted = recordHookEvent(context, {
+        projectId: project.id, protocolId: observedSession?.protocol_id ?? null, harness: "grok-acp", providerSessionId, parentSessionId,
+        daemonId: daemonId ?? null, sessionId, agentId: agentId ?? null, turnId: stringValue(hook.turn_id) ?? stringValue(hook.turnId) ?? null,
+        eventName: "PreToolUse", toolName: toolName ?? "Bash", status: "observed", payload, eventKey, matchKey, transcriptPath: null, cwd: expectedRoot
+    });
+    recordFlowSessionObservation(context, {
+        projectId: project.id, sessionId, runId: observedSession?.run_id ?? null, protocolId: observedSession?.protocol_id ?? null,
+        cwd: expectedRoot, toolName: toolName ?? "Bash", eventKey
+    });
+    const result = { ok: true, observed: inserted, duplicate: !inserted, event_key: eventKey, harness: "grok-acp", session_id: sessionId,
+        provider_session_id: providerSessionId, parent_session_id: parentSessionId, daemon_id: daemonId ?? null };
+    return (flowPayload || stageStart || stageResume || workStart)
+        ? { ...result, hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: { ...(rawInput ?? {}), command: commandWithHookEvent(command, eventKey) } } }
+        : result;
+}
+/** Convert a controlled OpenCode tool hook into the shared lifecycle receipt. */
+export function handleOpenCodeEvent(context, input) {
+    const event = parseJsonObject(input.stdin || "{}", "OpenCode tool event");
+    const agy = event.source_harness === "antigravity-cli";
+    const harness = agy ? "antigravity-cli" : "opencode-server";
+    if (event.schema_id !== "dd-flow/opencode-tool-event@1")
+        throw new AppError("unsupported_opencode_event_schema", "Unsupported OpenCode event schema", 1);
+    const phase = stringValue(event.phase);
+    if (phase !== "before" && phase !== "after")
+        throw new AppError("unsupported_opencode_event_schema", "OpenCode event phase must be before or after", 1);
+    const session = objectRecord(event.session);
+    const profile = objectRecord(event.profile);
+    const rawInput = objectRecord(event.input);
+    const providerSessionId = stringValue(session.provider_session_id);
+    const nativeParentId = stringValue(session.parent_provider_session_id);
+    const daemonId = stringValue(event.daemon_id);
+    const toolCallId = stringValue(event.tool_call_id);
+    const eventId = stringValue(event.event_id) ?? toolCallId;
+    const toolName = stringValue(event.tool);
+    const directory = stringValue(session.directory);
+    if (!providerSessionId || !daemonId || !toolCallId || !eventId || !toolName || !directory || !path.isAbsolute(directory)) {
+        throw new AppError("opencode_session_identity_invalid", "OpenCode event is missing trusted physical identity", 1);
+    }
+    const expectedRoot = resolveProjectRoot(input.projectRoot);
+    if (resolveProjectRoot(directory) !== expectedRoot) {
+        throw new AppError(agy ? "agy_directory_mismatch" : "opencode_directory_mismatch", `${agy ? "Antigravity" : "OpenCode"} Session directory does not match the controlled workspace`, 1, { expected: expectedRoot, actual: directory });
+    }
+    const sessionId = `${harness}:${providerSessionId}`;
+    const parentSessionId = nativeParentId ? `${harness}:${nativeParentId}` : null;
+    const command = stringValue(rawInput.command) ?? stringValue(rawInput.cmd) ?? stringValue(rawInput.CommandLine);
+    const baseKey = `${eventId}:${phase}`;
+    if (phase === "after") {
+        const project = requireProjectByRoot(context, expectedRoot);
+        const inserted = recordHookEvent(context, {
+            projectId: project.id, protocolId: null, harness, providerSessionId, parentSessionId,
+            daemonId, sessionId, agentId: stringValue(session.agent_id) ?? null, turnId: stringValue(event.message_id) ?? null,
+            eventName: "PostToolUse", toolName, status: "observed", payload: { session_id: providerSessionId, cwd: expectedRoot, tool_name: toolName, status: objectRecord(event.outcome).status },
+            eventKey: baseKey, matchKey: null, transcriptPath: null, cwd: expectedRoot
+        });
+        return { ok: true, observed: inserted, duplicate: !inserted, event_key: baseKey, phase, harness, session_id: sessionId };
+    }
+    if (!command || !["bash", "Bash", "run_command", "run_terminal_command", "RunTerminalCommand"].includes(toolName)) {
+        return { ok: true, observed: false, reason: command ? "non_bash_tool" : "event_not_participating" };
+    }
+    const stageResume = /\bdd-flow\s+stage\s+resume\b/.test(command);
+    const lifecycleShell = analyzeLifecycleShellCommand(command, true);
+    const agyBootstrapHeredoc = agy && containsUnquotedHeredoc(command) && /\bdd-flow\s+stage\s+start\b/.test(command) && /(?:^|\s)--bootstrap(?:\s|$)/.test(command);
+    const stagePauseHeredoc = containsUnquotedHeredoc(command) && /\bdd-flow\s+stage\s+pause\b/.test(command);
+    if (lifecycleShell.kind === "compound" && !stageResume && !agyBootstrapHeredoc && !stagePauseHeredoc) {
+        throw new AppError("compound_lifecycle_command", `dd-flow lifecycle commands must be a standalone ${agy ? "Antigravity" : "OpenCode"} shell tool call`, 1, { standalone_command: lifecycleShell.standaloneCommand });
+    }
+    const flowPayload = flowSessionPayloadFromRegisterCommand(command);
+    const stageStart = /\bdd-flow\s+stage\s+start\b/.test(command);
+    const workStart = /\bdd-flow\s+work\s+start\b/.test(command);
+    const bootstrapStageStart = stageStart && /(?:^|\s)--bootstrap(?:\s|$)/.test(command);
+    if (!flowPayload && !stageStart && !stageResume && !workStart)
+        return { ok: true, observed: false, reason: "event_not_participating" };
+    const commandProjectRoot = optionFromCommand(command, "project-root");
+    if (commandProjectRoot && resolveProjectRoot(commandProjectRoot) !== expectedRoot) {
+        throw new AppError("project_mismatch", "OpenCode lifecycle command project root does not match the controlled workspace", 1, { expected: expectedRoot, actual: commandProjectRoot });
+    }
+    const stageName = stageStart ? optionFromCommand(command, "stage") : undefined;
+    const resumeStageName = stageResume ? optionFromCommand(command, "stage") : undefined;
+    const stageRunId = stageStart && !bootstrapStageStart ? positionalFromCommand(command, "dd-flow stage start") : undefined;
+    const resumeRunId = stageResume ? positionalFromCommand(command, "dd-flow stage resume") : undefined;
+    const resumeWorkId = stageResume ? optionFromCommand(command, "work") : undefined;
+    const workId = workStart ? positionalFromCommand(command, "dd-flow work start") : undefined;
+    const contextSha256 = optionFromCommand(command, "context-sha256") ?? undefined;
+    const matchKey = bootstrapStageStart ? bootstrapMatchKey({
+        projectRoot: expectedRoot,
+        subject: optionFromCommand(command, "subject") ?? optionFromCommand(command, "slug") ?? "specify",
+        intakeMode: contextSha256 ? "context" : /(?:^|\s)--intake-stdin(?:\s|$)/.test(command) ? "stdin" : "file",
+        ...(contextSha256 ? { contextSha256 } : {})
+    }) : stageStart && stageRunId && stageName ? stageStartMatchKey(stageRunId, stageName, expectedRoot, contextSha256)
+        : stageResume && resumeRunId && resumeStageName && resumeWorkId ? stageResumeMatchKey(resumeRunId, resumeStageName, resumeWorkId, expectedRoot)
+            : workStart && workId ? workStartMatchKey(workId, expectedRoot) : null;
+    if (bootstrapStageStart)
+        registerProject(context, { root: expectedRoot });
+    const project = requireProjectByRoot(context, expectedRoot);
+    const agentId = stringValue(session.agent_id);
+    const observedSession = flowPayload ? bindObservedFlowSession(context, project, {
+        ...flowPayload, harness, provider_session_id: providerSessionId, agent_id: agentId ?? null,
+        parent_session_id: parentSessionId, provider: stringValue(profile.provider) ?? null, model: stringValue(profile.model) ?? null,
+        reasoning: stringValue(profile.variant) ?? null, mode: stringValue(profile.agent) ?? null, agent_type: stringValue(profile.agent) ?? null,
+        metadata: { opencode_version: stringValue(event.server_version) ?? null, api_fingerprint: stringValue(event.api_fingerprint) ?? null, plugin_sha256: stringValue(event.plugin_sha256) ?? null, native_project_id: stringValue(session.project_id) ?? null }
+    }, sessionId) : undefined;
+    const payload = {
+        session_id: providerSessionId, agent_id: agentId, cwd: expectedRoot, tool_name: toolName, tool_input: rawInput, command,
+        provider: stringValue(profile.provider), model: stringValue(profile.model), reasoning: stringValue(profile.variant),
+        mode: stringValue(profile.agent), agent_type: stringValue(profile.agent)
+    };
+    const inserted = recordHookEvent(context, {
+        projectId: project.id, protocolId: observedSession?.protocol_id ?? null, harness, providerSessionId, parentSessionId,
+        daemonId, sessionId, agentId: agentId ?? null, turnId: stringValue(event.message_id) ?? null, eventName: "PreToolUse", toolName,
+        status: "observed", payload, eventKey: baseKey, matchKey, transcriptPath: null, cwd: expectedRoot
+    });
+    recordFlowSessionObservation(context, { projectId: project.id, sessionId, runId: observedSession?.run_id ?? null, protocolId: observedSession?.protocol_id ?? null, cwd: expectedRoot, toolName, eventKey: baseKey });
+    const result = { ok: true, observed: inserted, duplicate: !inserted, event_key: baseKey, phase, harness, session_id: sessionId, provider_session_id: providerSessionId, parent_session_id: parentSessionId, daemon_id: daemonId };
+    return agy ? result : { ...result, hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: { ...rawInput, command: commandWithHookEvent(command, baseKey) } } };
+}
+/** Convert an Antigravity CLI tool hook into the shared lifecycle receipt. */
+export function handleAgyEvent(context, input) {
+    const event = parseJsonObject(input.stdin || "{}", "Antigravity tool event");
+    if (event.schema_id !== "dd-flow/agy-tool-event@1")
+        throw new AppError("unsupported_agy_event_schema", "Unsupported Antigravity event schema", 1);
+    const workspacePaths = Array.isArray(event.workspace_paths) ? event.workspace_paths : [];
+    const directory = workspacePaths.find((value) => typeof value === "string" && path.isAbsolute(value));
+    const providerSessionId = stringValue(event.conversation_id);
+    const daemonId = stringValue(event.daemon_id);
+    const eventId = stringValue(event.event_id);
+    const toolName = stringValue(event.tool);
+    if (!directory || !providerSessionId || !daemonId || !eventId || !toolName)
+        throw new AppError("agy_session_identity_invalid", "Antigravity event is missing trusted physical identity", 1);
+    const translated = {
+        schema_id: "dd-flow/opencode-tool-event@1", source_harness: "antigravity-cli", phase: event.phase, event_id: eventId,
+        daemon_id: daemonId, tool_call_id: eventId, tool: toolName, input: event.input,
+        message_id: event.step_index === undefined ? null : String(event.step_index),
+        session: { provider_session_id: providerSessionId, parent_provider_session_id: event.parent_conversation_id, directory },
+        profile: { provider: objectRecord(event.profile).provider, model: objectRecord(event.profile).model, variant: objectRecord(event.profile).reasoning, agent: objectRecord(event.profile).mode },
+        outcome: { status: stringValue(event.error) ? "error" : "completed" }
+    };
+    return handleOpenCodeEvent(context, { projectRoot: input.projectRoot, stdin: JSON.stringify(translated) });
+}
+/**
+ * A Desktop hook inherits the app environment, not an inline `VAR=value`
+ * assignment made by the pending Bash tool call. Find the explicit
+ * DD_FLOW_HOME assignment for the dd-flow invocation, including a safe stdin
+ * pipeline such as `cat <<EOF | CODEX_HOME=... DD_FLOW_HOME=... dd-flow`.
+ * Other shell syntax is deliberately not evaluated here.
+ */
+export function isolatedDdFlowHomeFromHookStdin(stdin) {
+    try {
+        const payload = parseJsonObject(stdin || "{}", "codex hook stdin");
+        const command = lifecycleCommandFromPayload(payload);
+        const direct = command?.match(/(?:^|[|;\r\n]\s*)(?:env\s+)?(?:(?!DD_FLOW_HOME=)[A-Za-z_][A-Za-z0-9_]*=(?:'[^']*'|"[^"]*"|[^\s|;]+)\s+)*DD_FLOW_HOME=(['"]?)([^\s'";|]+)\1\s+dd-flow\b/);
+        // An exported home applies to the following pipeline command; this is the
+        // other form emitted by generated commands that send stdin through a pipe.
+        const exported = command?.match(/(?:^|[;\r\n]\s*)export\s+DD_FLOW_HOME=(['"]?)([^\s'";|]+)\1(?=\s*(?:[;\r\n]|$))/);
+        const home = direct?.[2] ?? exported?.[2];
+        return home && path.isAbsolute(home) ? path.resolve(home) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Desktop can wrap a single Bash tool invocation in `bash -c "…"`.  Keep the
+ * hook contract intentionally narrow: unwrap only that whole-command form,
+ * then apply the same lifecycle parser to its actual shell payload.
+ */
+function lifecycleCommandFromPayload(payload) {
+    const command = commandFromPayload(payload);
+    if (!command)
+        return undefined;
+    const wrapped = command.trim().match(/^(?:\S*\/)?bash\s+-c\s+"((?:\\.|[^"\\])*)"\s*$/);
+    return wrapped ? wrapped[1].replace(/\\([\\"])/g, "$1") : command;
+}
+function commandWithHookEvent(command, eventKey) {
+    if (/(?:^|\s)--hook-event-id(?:=|\s)/.test(command))
+        return command;
+    // Heredoc payloads are opaque bytes from the user. Appending a flag to the
+    // whole Bash command changes those bytes and corrupts `stage resume` input.
+    if (containsUnquotedHeredoc(command))
         return command;
-    return `${command} --session-id ${JSON.stringify(sessionId)}`;
+    if (/^\s*dd-flow\s+session\s+register\b/.test(command) && !/[;|&\n\r]|\$\(/.test(command))
+        return `${command.trim()} --hook-event-id ${JSON.stringify(eventKey)}`;
+    const lifecycle = analyzeLifecycleShellCommand(command, true);
+    if (lifecycle.kind !== "standalone")
+        return command;
+    return `${lifecycle.standaloneCommand} --hook-event-id ${JSON.stringify(eventKey)}`;
+}
+function containsUnquotedHeredoc(command) {
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < command.length - 1; index += 1) {
+        const char = command[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\" && quote !== "'") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            continue;
+        }
+        if (char === "<" && command[index + 1] === "<")
+            return true;
+    }
+    return false;
+}
+/**
+ * Recognise the small shell surface used by generated dd-flow lifecycle
+ * commands. This intentionally does not evaluate Bash: ambiguous composition
+ * is rejected so a hook event can never bind the wrong command.
+ */
+export function analyzeLifecycleShellCommand(command, includeSessionRegister = false) {
+    const segments = [];
+    let start = 0;
+    let quote = null;
+    let escaped = false;
+    let compound = false;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\" && quote !== "'") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            continue;
+        }
+        const pair = command.slice(index, index + 2);
+        if (pair === "$(" || pair === "&&" || pair === "||") {
+            compound = true;
+            segments.push(command.slice(start, index).trim());
+            index += 1;
+            start = index + 1;
+            continue;
+        }
+        if (char === ";" || char === "|" || char === "&" || char === "\n" || char === "\r" || char === "(") {
+            compound = true;
+            segments.push(command.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    segments.push(command.slice(start).trim());
+    // `stage resume` intentionally accepts the user's complete answer on stdin.
+    // We recognise it for observability but never rewrite a compound invocation.
+    const lifecyclePattern = includeSessionRegister
+        ? /\bdd-flow\s+(?:session\s+register|stage\s+(?:start|resume)|work\s+start)\b/
+        : /\bdd-flow\s+(?:stage\s+(?:start|resume)|work\s+start)\b/;
+    const lifecycle = segments.filter((segment) => lifecyclePattern.test(segment));
+    if (!lifecycle.length)
+        return { kind: "none" };
+    const standaloneCommand = lifecycle[0];
+    return compound || lifecycle.length !== 1
+        ? { kind: "compound", standaloneCommand }
+        : { kind: "standalone", standaloneCommand };
+}
+/** Trusted session identity is created by PreToolUse, never supplied by an agent. */
+export function sessionIdForHookEvent(context, projectId, eventKey) {
+    const event = context.db.get("SELECT session_id FROM hook_events WHERE project_id = ? AND event_key = ?", [projectId, eventKey]);
+    if (!event?.session_id) {
+        throw new AppError("hook_event_not_found", "stage start requires a trusted PreToolUse hook event", 1, { event_key: eventKey });
+    }
+    return event.session_id;
+}
+/** Reads immutable identity facts already captured by PreToolUse. */
+export function hookSessionIdentity(context, projectId, eventKey) {
+    const event = context.db.get(`SELECT he.id, he.harness, he.provider_session_id, he.parent_session_id, he.daemon_id, he.session_id, he.agent_id, he.turn_id, he.transcript_path, he.provider, he.model, he.reasoning, he.mode, he.agent_type, COALESCE(he.cwd, csb.cwd) AS cwd
+     FROM hook_events he LEFT JOIN codex_session_bindings csb ON csb.project_id = he.project_id AND csb.session_id = he.session_id
+     WHERE he.project_id = ? AND he.event_key = ?`, [projectId, eventKey]);
+    if (!event?.session_id)
+        throw new AppError("hook_event_not_found", "stage start requires a trusted PreToolUse hook event", 1, { event_key: eventKey });
+    return {
+        hookEventId: event.id,
+        harness: event.harness,
+        providerSessionId: event.provider_session_id ?? event.session_id,
+        parentSessionId: event.parent_session_id,
+        daemonId: event.daemon_id,
+        agentId: event.agent_id,
+        sessionId: event.harness === "codex-desktop" ? event.agent_id ?? event.session_id : event.session_id,
+        turnId: event.turn_id,
+        transcriptPath: event.transcript_path,
+        provider: event.provider,
+        model: event.model,
+        reasoning: event.reasoning,
+        mode: event.mode,
+        agentType: event.agent_type,
+        cwd: event.cwd
+    };
+}
+/**
+ * Claims the short-lived PreToolUse event for a lifecycle command when its host
+ * cannot apply `updatedInput` to a nested Bash invocation. The match key is
+ * derived from immutable command arguments; an event remains single-use.
+ */
+export function claimRecentMatchingHookEvent(context, input) {
+    const event = findRecentMatchingHookEvent(context, input);
+    const claim = context.db.run("UPDATE hook_events SET status = 'claimed', claimed_at = ? WHERE id = ? AND status = 'observed'", [context.now(), event.id]);
+    if (claim.changes !== 1) {
+        throw new AppError(input.errorCode, `matching ${input.operation} PreToolUse hook event was already claimed`, 1);
+    }
+    return event.eventKey;
+}
+/** Finds the trusted event that a stage- or Work-specific claimant will atomically claim. */
+export function findRecentMatchingHookEvent(context, input) {
+    const freshAfter = new Date(Date.parse(context.now()) - 60_000).toISOString();
+    const find = () => context.db.get(`SELECT id, event_key FROM hook_events
+     WHERE project_id = ? AND match_key = ? AND status = 'observed' AND created_at >= ?
+     ORDER BY id DESC LIMIT 1`, [input.projectId, input.matchKey, freshAfter]);
+    let event = find();
+    // Some harnesses publish nested-agent tool events concurrently with command
+    // execution. Give the trusted event a short bounded window to reach SQLite.
+    const deadline = Date.now() + 250;
+    while (!event?.event_key && Date.now() < deadline) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        event = find();
+    }
+    if (!event?.event_key) {
+        throw new AppError(input.errorCode, `${input.operation} requires one matching harness lifecycle event. Stay in this Session and retry the exact standalone lifecycle command; do not create a new Session.`, 1);
+    }
+    return { id: event.id, eventKey: event.event_key };
+}
+/** Fallback for Desktop paths that execute the original command after a hook rewrite. */
+export function claimBootstrapHookEvent(context, input) {
+    return claimRecentMatchingHookEvent(context, {
+        projectId: input.projectId,
+        matchKey: bootstrapMatchKey(input),
+        errorCode: "trusted_session_binding_required",
+        operation: "vNext SPECIFY start"
+    });
+}
+export function bootstrapMatchKey(input) {
+    return crypto.createHash("sha256").update(JSON.stringify({
+        operation: "stage_start",
+        bootstrap: true,
+        stage: "specify",
+        project_root: resolveProjectRoot(input.projectRoot),
+        subject: input.subject,
+        intake_mode: input.intakeMode,
+        ...(input.contextSha256 ? { context_sha256: input.contextSha256 } : {})
+    })).digest("hex");
+}
+export function claimWorkStartHookEvent(context, input) {
+    const expected = new Set([workStartMatchKey(input.workId, input.projectRoot), workStartMatchKey(shortWorkReference(input.workId), input.projectRoot)]);
+    const event = context.db.get("SELECT id, session_id, agent_id, turn_id, transcript_path, model, agent_type, match_key, status FROM hook_events WHERE project_id = ? AND event_key = ?", [input.projectId, input.eventKey]);
+    if (!event?.session_id || event.status !== "observed" || !event.match_key || !expected.has(event.match_key)) {
+        throw new AppError("trusted_work_launch_required", "work start requires one fresh matching PreToolUse event", 1, { work_id: input.workId, event_key: input.eventKey });
+    }
+    const claimed = context.db.run("UPDATE hook_events SET status = 'claimed', claimed_at = ? WHERE id = ? AND status = 'observed'", [context.now(), event.id]);
+    if (claimed.changes !== 1)
+        throw new AppError("trusted_work_launch_required", "matching work-start hook event was already claimed", 1, { work_id: input.workId });
+    return hookSessionIdentity(context, input.projectId, input.eventKey);
+}
+function shortWorkReference(id) { return /^WRK-\d{3,}(?:-|$)/.exec(id)?.[0]?.replace(/-$/, "") ?? id; }
+/** Claims the exact non-bootstrap stage entry which starts a coordinator Work. */
+export function assertStageStartHookEvent(context, input) {
+    const expected = stageStartMatchKey(input.runId, input.stage, input.projectRoot, input.contextSha256);
+    const event = context.db.get("SELECT session_id, match_key, status FROM hook_events WHERE project_id = ? AND event_key = ?", [input.projectId, input.eventKey]);
+    if (!event?.session_id || event.status !== "observed" || event.match_key !== expected) {
+        throw new AppError("trusted_stage_launch_required", "stage start requires one fresh matching PreToolUse event", 1, { run_id: input.runId, stage: input.stage, event_key: input.eventKey });
+    }
+    return hookSessionIdentity(context, input.projectId, input.eventKey);
+}
+export function claimStageStartHookEvent(context, input) {
+    assertStageStartHookEvent(context, input);
+    const event = context.db.get("SELECT id FROM hook_events WHERE project_id = ? AND event_key = ?", [input.projectId, input.eventKey]);
+    const claimed = context.db.run("UPDATE hook_events SET status = 'claimed', claimed_at = ? WHERE id = ? AND status = 'observed'", [context.now(), event.id]);
+    if (claimed.changes !== 1)
+        throw new AppError("trusted_stage_launch_required", "matching stage-start hook event was already claimed", 1, { run_id: input.runId, stage: input.stage });
+    return hookSessionIdentity(context, input.projectId, input.eventKey);
+}
+export function stageStartMatchKey(runId, stage, projectRoot, contextSha256) {
+    return crypto.createHash("sha256").update(JSON.stringify({
+        operation: "stage_start",
+        run_id: runId,
+        stage,
+        project_root: resolveProjectRoot(projectRoot),
+        ...(contextSha256 ? { context_sha256: contextSha256 } : {})
+    })).digest("hex");
+}
+export function stageResumeMatchKey(runId, stage, workId, projectRoot) {
+    return crypto.createHash("sha256").update(JSON.stringify({
+        operation: "stage_resume",
+        run_id: runId,
+        stage,
+        work_id: workId,
+        project_root: resolveProjectRoot(projectRoot)
+    })).digest("hex");
+}
+/** Claims the resume command observed in the Session that received the user answer. */
+export function claimStageResumeHookEvent(context, input) {
+    const matchKey = stageResumeMatchKey(input.runId, input.stage, input.workId, input.projectRoot);
+    const freshAfter = new Date(Date.parse(context.now()) - 60_000).toISOString();
+    const event = input.eventKey
+        ? context.db.get("SELECT id, event_key, session_id, match_key, status FROM hook_events WHERE project_id = ? AND event_key = ?", [input.projectId, input.eventKey])
+        : context.db.get("SELECT id, event_key, session_id, match_key, status FROM hook_events WHERE project_id = ? AND session_id = ? AND match_key = ? AND status = 'observed' AND created_at >= ? ORDER BY id DESC LIMIT 1", [input.projectId, input.sessionId ?? "", matchKey, freshAfter]);
+    if (!event?.event_key || !event.session_id || event.match_key !== matchKey || event.status !== "observed") {
+        throw new AppError("trusted_stage_resume_required", "stage resume requires one fresh matching PreToolUse event", 1, { run_id: input.runId, stage: input.stage, work_id: input.workId });
+    }
+    const claimed = context.db.run("UPDATE hook_events SET status = 'claimed', claimed_at = ? WHERE id = ? AND status = 'observed'", [context.now(), event.id]);
+    if (claimed.changes !== 1)
+        throw new AppError("trusted_stage_resume_required", "matching stage-resume hook event was already claimed", 1, { run_id: input.runId, stage: input.stage });
+    return hookSessionIdentity(context, input.projectId, event.event_key);
+}
+export function workStartMatchKey(workId, projectRoot) {
+    return crypto.createHash("sha256").update(JSON.stringify({
+        operation: "work_start",
+        work_id: workId,
+        project_root: resolveProjectRoot(projectRoot)
+    })).digest("hex");
 }
 export function hookStatusForProject(context, projectId) {
     return context.db.all(`SELECT scope, config_path, content_hash, installed, drift_status, updated_at
@@ -343,6 +1020,11 @@ export function activeCodexSessionBindingsForProject(context, projectId) {
     return context.db.all(`SELECT session_id, protocol_id, handshake_id, cwd, transcript_path, status, continuation_count, updated_at
      FROM codex_session_bindings WHERE project_id = ? AND status = 'active' ORDER BY updated_at DESC`, [projectId]);
 }
+/** Resolve the transcript once at the hook boundary; agents never provide this path. */
+export function transcriptPathForCodexSession(context, projectRoot, sessionId) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(projectRoot));
+    return sessionBinding(context, project.id, sessionId)?.transcript_path ?? locateCodexTranscript(sessionId, context.env.CODEX_HOME);
+}
 export function activeFlowSessionBindingsForProject(context, projectId) {
     return activeFlowSessionsForProject(context, projectId).map((session) => ({
         session_id: session.session_id,
@@ -360,7 +1042,7 @@ export function activeFlowSessionBindingsForProject(context, projectId) {
 }
 export function codexHookEventsForProject(context, projectId) {
     return context.db.all(`SELECT protocol_id, session_id, turn_id, event_name, tool_name, status, sanitized_summary, created_at
-     FROM codex_hook_events WHERE project_id = ? ORDER BY created_at DESC, id DESC LIMIT 20`, [projectId]);
+     FROM hook_events WHERE project_id = ? ORDER BY created_at DESC, id DESC LIMIT 20`, [projectId]);
 }
 function resolveProfileName(profile) {
     return sanitizeProfile(profile ?? defaultProfileName);
@@ -473,7 +1155,8 @@ function commandHook(command, statusMessage) {
     return { type: "command", command, timeout: 5, statusMessage };
 }
 function hookCommand(event) {
-    return `PATH="\${HOME}/Library/pnpm:/opt/homebrew/bin:/usr/local/bin:\${PATH}" dd-flow codex hook handle --event ${event} --json`;
+    const handler = `PATH="\${HOME}/Library/pnpm:/opt/homebrew/bin:/usr/local/bin:\${PATH}" dd-flow codex hook handle --event ${event} --json`;
+    return `/bin/bash -c 'log_dir="\${DD_FLOW_HOME:-\${HOME}/.dd-flow}/logs"; mkdir -p "$log_dir"; log="$log_dir/codex-hook.log"; printf "%s event=${event} phase=start pid=%s\\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$$" >>"$log"; ${handler} 2> >(tee -a "$log" >&2); status=$?; printf "%s event=${event} phase=finish pid=%s exit=%s\\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$$" "$status" >>"$log"; exit "$status"'`;
 }
 function resolveHookTarget(target) {
     if (!target || target === "isolated") {
@@ -652,7 +1335,7 @@ function upsertSessionBindingFromPayload(context, project, sessionId, payload) {
     const existing = sessionBinding(context, project.id, sessionId);
     const now = context.now();
     const cwd = stringValue(payload.cwd) ?? existing?.cwd ?? null;
-    const transcriptPath = stringValue(payload.transcript_path) ?? existing?.transcript_path ?? null;
+    const transcriptPath = stringValue(payload.transcript_path) ?? existing?.transcript_path ?? locateCodexTranscript(sessionId, context.env.CODEX_HOME);
     context.db.run(`INSERT INTO codex_session_bindings
       (session_id, project_id, protocol_id, handshake_id, cwd, transcript_path, status, created_at, updated_at)
      VALUES (?, ?, NULL, NULL, ?, ?, 'active', ?, ?)
@@ -663,21 +1346,73 @@ function upsertSessionBindingFromPayload(context, project, sessionId, payload) {
        updated_at = excluded.updated_at`, [sessionId, project.id, cwd, transcriptPath, now, now]);
     return sessionBinding(context, project.id, sessionId);
 }
+function locateCodexTranscript(sessionId, configuredHome) {
+    // The hook runs inside one selected CODEX_HOME.  An explicit profile must
+    // not also scan unrelated real homes; that breaks isolation and can attach
+    // a transcript from a different client.  Only an unconfigured legacy call
+    // probes the two conventional locations.
+    const homes = configuredHome
+        ? [configuredHome]
+        : [path.join(os.homedir(), ".codex"), path.join(os.homedir(), ".codex-cpa")];
+    for (const home of homes) {
+        for (const directory of recentCodexSessionDirectories(home)) {
+            const found = findTranscript(directory, sessionId);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+function findTranscript(root, sessionId) {
+    if (!fs.existsSync(root))
+        return null;
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".jsonl") && entry.name.includes(sessionId))
+            return path.join(root, entry.name);
+    }
+    return null;
+}
+function recentCodexSessionDirectories(home) {
+    return [0, 1].map((daysAgo) => {
+        const date = new Date(Date.now() - daysAgo * 24 * 60 * 60 * 1000);
+        return path.join(home, "sessions", String(date.getUTCFullYear()), String(date.getUTCMonth() + 1).padStart(2, "0"), String(date.getUTCDate()).padStart(2, "0"));
+    });
+}
 function sessionBinding(context, projectId, sessionId) {
     return context.db.get("SELECT * FROM codex_session_bindings WHERE project_id = ? AND session_id = ?", [projectId, sessionId]);
 }
 function recordHookEvent(context, input) {
-    const existing = context.db.get("SELECT id FROM codex_hook_events WHERE project_id = ? AND event_key = ?", [input.projectId, input.eventKey]);
+    const existing = context.db.get("SELECT id FROM hook_events WHERE project_id = ? AND event_key = ?", [input.projectId, input.eventKey]);
     if (existing)
         return false;
-    context.db.run(`INSERT INTO codex_hook_events
-      (project_id, protocol_id, session_id, turn_id, event_key, event_name, tool_name, status, sanitized_summary, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    context.db.run(`INSERT INTO hook_events
+      (project_id, protocol_id, harness, provider_session_id, parent_session_id, daemon_id, session_id, agent_id, turn_id, transcript_path, provider, model, reasoning, mode, agent_type, cwd, event_key, match_key, event_name, tool_name, status, sanitized_summary, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
         input.projectId,
         input.protocolId,
+        input.harness,
+        input.providerSessionId,
+        input.parentSessionId,
+        input.daemonId ?? null,
         input.sessionId,
+        input.agentId,
         input.turnId,
+        stringValue(input.payload.transcript_path) ?? input.transcriptPath,
+        stringValue(input.payload.provider) ?? null,
+        stringValue(input.payload.model) ?? null,
+        stringValue(input.payload.reasoning) ?? null,
+        stringValue(input.payload.mode) ?? null,
+        stringValue(input.payload.agent_type) ?? null,
+        input.cwd,
         input.eventKey,
+        input.matchKey,
         input.eventName,
         input.toolName,
         input.status,
@@ -700,6 +1435,27 @@ function projectForHook(context, explicitRoot, cwd) {
     })
         .sort((left, right) => right.root.length - left.root.length)[0];
 }
+function optionFromCommand(command, name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = command.match(new RegExp(`(?:^|\\s)--${escaped}(?:=|\\s+)("(?:[^"\\\\]|\\\\.)*"|'(?:[^'\\\\]|\\\\.)*'|[^\\s]+)`));
+    return match?.[1] ? shellArgument(match[1]) : undefined;
+}
+function positionalFromCommand(command, prefix) {
+    const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = command.match(new RegExp(`\\b${escaped}\\s+("(?:[^"\\\\]|\\\\.)*"|'(?:[^'\\\\]|\\\\.)*'|[^\\s]+)`));
+    return match?.[1] ? shellArgument(match[1]) : undefined;
+}
+function shellArgument(raw) {
+    if (raw.startsWith('"')) {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return raw.startsWith("'") ? raw.slice(1, -1) : raw;
+}
 function hookEventKey(payload, eventName, toolName, command) {
     const explicit = stringValue(payload.tool_use_id) ?? stringValue(payload.event_id) ?? stringValue(payload.delivery_id) ?? stringValue(payload.id);
     if (explicit)