@amsterdamdatalabs/enact-operator 0.1.2

package/runtime/hooks/lanes/resolveSkillActivation.mjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { startAutopilot, retargetAutopilot } from '@amsterdamdatalabs/enact-operator/autopilot';
+import { activateActiveSkill } from '@amsterdamdatalabs/enact-operator/activeSkill';
+import { startRalph, retargetRalph } from '@amsterdamdatalabs/enact-operator/ralph';
+import { createTeam } from '@amsterdamdatalabs/enact-operator/team';
+import { startUltrawork, retargetUltrawork } from '@amsterdamdatalabs/enact-operator/ultrawork';
+import {
+  executeActivation,
+  listKnownSkills,
+  parseSkillActivation,
+  recordActivation,
+} from '@amsterdamdatalabs/enact-operator/skillActivation';
+
+const ACTIVE_SKILL_LANES = new Set(['autopilot', 'ralph', 'ralplan', 'team', 'ultrawork', 'ultragoal', 'ultraqa']);
+
+function parseInput() {
+  try {
+    const raw = readFileSync(0, 'utf8');
+    if (!raw) {
+      return null;
+    }
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.root !== 'string' || typeof parsed.prompt !== 'string') {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function applyActivation(root, result) {
+  if (!result.requiredAction) {
+    return result;
+  }
+
+  const { tool } = result.requiredAction;
+  const params = result.requiredAction.params ?? {};
+
+  if (tool === 'operator_ralph_start' || tool === 'operator_ralph_start') {
+    const started = startRalph(root, {
+      goal: String(params.goal),
+      goalScope: typeof params.goalScope === 'string' ? params.goalScope : undefined,
+      gateProfile: typeof params.gateProfile === 'string' ? params.gateProfile : undefined,
+      linkedUltraworkId: typeof params.linkedUltraworkId === 'string' ? params.linkedUltraworkId : undefined,
+      activationMetadata: params.activationMetadata,
+    });
+    return { ...result, startedStateId: started.id };
+  }
+
+  if (tool === 'operator_team_init' || tool === 'operator_team_init') {
+    const teamOptions =
+      typeof params.initialTaskTitle === 'string' || typeof params.initialOwner === 'string'
+        ? {
+            initialTaskTitle:
+              typeof params.initialTaskTitle === 'string' ? params.initialTaskTitle : undefined,
+            initialOwner: typeof params.initialOwner === 'string' ? params.initialOwner : undefined,
+          }
+        : undefined;
+    const started = createTeam(
+      root,
+      String(params.name),
+      Array.isArray(params.executors) ? params.executors : [
+        { id: 'executor', role: 'executor' },
+        { id: 'reviewer', role: 'reviewer' },
+        { id: 'tester', role: 'tester' },
+        { id: 'documenter', role: 'documenter' },
+      ],
+      typeof params.baseBranch === 'string' ? params.baseBranch : 'main',
+      teamOptions,
+    );
+    return { ...result, startedStateId: started.id };
+  }
+
+  if (tool === 'operator_autopilot_start' || tool === 'operator_autopilot_start') {
+    const started = startAutopilot(root, {
+      intent: String(params.intent),
+      goalScope: typeof params.goalScope === 'string' ? params.goalScope : undefined,
+      gateProfile: typeof params.gateProfile === 'string' ? params.gateProfile : undefined,
+      activationMetadata: params.activationMetadata,
+    });
+    return { ...result, startedStateId: started.id };
+  }
+
+  if (tool === 'operator_ultrawork_start' || tool === 'operator_ultrawork_start') {
+    const started = startUltrawork(root, {
+      intent: String(params.intent),
+      goalScope: typeof params.goalScope === 'string' ? params.goalScope : undefined,
+      gateProfile: typeof params.gateProfile === 'string' ? params.gateProfile : undefined,
+      activationMetadata: params.activationMetadata,
+    });
+    return { ...result, startedStateId: started.id };
+  }
+
+  if (tool === 'operator_autopilot_retarget' || tool === 'operator_autopilot_retarget') {
+    retargetAutopilot(root, {
+      intent: String(params.intent),
+      mode: params.mode,
+      goalScope: typeof params.goalScope === 'string' ? params.goalScope : undefined,
+      gateProfile: typeof params.gateProfile === 'string' ? params.gateProfile : undefined,
+      note: typeof params.note === 'string' ? params.note : undefined,
+      by: typeof params.by === 'string' ? params.by : undefined,
+    });
+    return result;
+  }
+
+  if (tool === 'operator_ralph_retarget' || tool === 'operator_ralph_retarget') {
+    retargetRalph(root, {
+      goal: String(params.goal),
+      mode: params.mode,
+      goalScope: typeof params.goalScope === 'string' ? params.goalScope : undefined,
+      gateProfile: typeof params.gateProfile === 'string' ? params.gateProfile : undefined,
+      linkedUltraworkId: typeof params.linkedUltraworkId === 'string' ? params.linkedUltraworkId : undefined,
+      note: typeof params.note === 'string' ? params.note : undefined,
+      by: typeof params.by === 'string' ? params.by : undefined,
+    });
+    return result;
+  }
+
+  if (tool === 'operator_ultrawork_retarget' || tool === 'operator_ultrawork_retarget') {
+    retargetUltrawork(root, {
+      intent: String(params.intent),
+      mode: params.mode,
+      goalScope: typeof params.goalScope === 'string' ? params.goalScope : undefined,
+      gateProfile: typeof params.gateProfile === 'string' ? params.gateProfile : undefined,
+      note: typeof params.note === 'string' ? params.note : undefined,
+      by: typeof params.by === 'string' ? params.by : undefined,
+    });
+    return result;
+  }
+
+  throw new Error(`Unsupported activation action tool "${tool}".`);
+}
+
+function normalizeKnownSkills(request) {
+  if (Array.isArray(request.knownSkills) && request.knownSkills.length > 0) {
+    return request.knownSkills;
+  }
+  return listKnownSkills(request.root);
+}
+
+function laneMetadata(skill) {
+  return { lane: ACTIVE_SKILL_LANES.has(skill) };
+}
+
+function extractModelIdentity(req) {
+  const explicit =
+    typeof req.modelId === 'string' ? req.modelId :
+    typeof req.model_id === 'string' ? req.model_id :
+    typeof req.model === 'string' ? req.model :
+    null;
+  if (explicit && explicit.trim()) {
+    return explicit.trim();
+  }
+  const headers = req.headers;
+  if (headers && typeof headers === 'object') {
+    const value =
+      headers['X-Model-Identity'] ??
+      headers['x-model-identity'] ??
+      headers['x_model_identity'];
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+function enrichVariantSelection(req, result) {
+  const skill = result?.intent?.skill;
+  if (typeof skill !== 'string') {
+    return result;
+  }
+  const modelIdentity = extractModelIdentity(req);
+  if (result.requiredAction?.params?.activationMetadata && typeof result.requiredAction.params.activationMetadata === 'object') {
+    result.requiredAction.params.activationMetadata = {
+      ...result.requiredAction.params.activationMetadata,
+      modelIdentity,
+    };
+  }
+  return {
+    ...result,
+    modelIdentity,
+  };
+}
+
+function syncActiveSkill(root, skill) {
+  if (!ACTIVE_SKILL_LANES.has(skill)) {
+    return;
+  }
+  if (!laneMetadata(skill).lane) {
+    return;
+  }
+  activateActiveSkill(root, skill, 'resolveSkillActivation');
+}
+
+function main() {
+  const request = parseInput();
+  if (!request) {
+    process.stdout.write('null');
+    return;
+  }
+
+  const knownSkills = normalizeKnownSkills(request);
+  const intent = parseSkillActivation(request.prompt, 'hook', knownSkills);
+  if (!intent) {
+    process.stdout.write('null');
+    return;
+  }
+
+  const result = enrichVariantSelection(request, executeActivation(request.root, intent));
+  if (request.dryRun || result.activated || result.requiredAction === null) {
+    if (!request.dryRun) {
+      if (result.activated) {
+        syncActiveSkill(request.root, result.intent.skill);
+      }
+      recordActivation(request.root, result);
+    }
+    process.stdout.write(JSON.stringify(result));
+    return;
+  }
+
+  try {
+    const next = applyActivation(request.root, result);
+    if (next.startedStateId) {
+      syncActiveSkill(request.root, next.intent.skill);
+    }
+    recordActivation(request.root, next);
+    process.stdout.write(JSON.stringify(next));
+  } catch (error) {
+    const failure = {
+      ...result,
+      activated: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+    recordActivation(request.root, failure);
+    process.stdout.write(JSON.stringify(failure));
+  }
+}
+
+main();

package/runtime/hooks/lanes/user-prompt-submit.mjs

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { emitHookFired, registerHookFailureTrap } from "../shared/observability.mjs";
+import { readMergedOperatorConfig } from "../shared/config.mjs";
+import { rootDirFrom } from "../shared/root-dir.mjs";
+import { layoutDir, layoutPath } from "../shared/layout-dir.mjs";
+import { readHooksVerbose, verboseLog } from "../shared/_lib.mjs";
+
+function readStdin() {
+  try {
+    return JSON.parse(readFileSync(0, "utf8") || "{}");
+  } catch {
+    return {};
+  }
+}
+
+function readJson(path, fallback) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(value, null, 2), "utf8");
+}
+
+function packageRoot() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+}
+
+function readWorkspaceConfig() {
+  return readMergedOperatorConfig(process.cwd());
+}
+
+const { touchContinuationActivity } = await import("@amsterdamdatalabs/enact-operator/continuation");
+const { findHeadQueuedFollowUp } = await import("@amsterdamdatalabs/enact-operator/continuationFollowUp");
+
+function detectScopedWorkspace(prompt) {
+  if (typeof prompt !== 'string') return null;
+  const match = prompt.match(/Work only inside\s+"?([^"\n]+)"?/i);
+  if (!match) return null;
+  const candidate = match[1].trim();
+  if (!candidate) return null;
+  return candidate;
+}
+
+function chooseOperatorRoot(defaultRoot, prompt, skill) {
+  if (!RUNTIME_CLASS_SKILLS.has(skill)) {
+    return defaultRoot;
+  }
+  const scopedWorkspace = detectScopedWorkspace(prompt);
+  if (!scopedWorkspace) {
+    return defaultRoot;
+  }
+  const resolvedWorkspace = resolve(scopedWorkspace);
+  if (!existsSync(resolvedWorkspace)) {
+    return defaultRoot;
+  }
+  if (
+    existsSync(join(resolvedWorkspace, 'config.toml'))
+    || existsSync(join(resolvedWorkspace, 'package.json'))
+    || existsSync(join(resolvedWorkspace, 'README.md'))
+  ) {
+    try {
+      return rootDirFrom(resolvedWorkspace);
+    } catch {
+      return defaultRoot;
+    }
+  }
+  return defaultRoot;
+}
+
+function needsBootstrap(root) {
+  const installRegistry = readJson(layoutPath(root, "state", "install-registry.json"), null);
+  const tasksPath = layoutPath(root, "state", "tasks.json");
+  const tasks = readJson(tasksPath, null);
+  const session = readJson(layoutPath(root, "sessions", "current.json"), null);
+  return (
+    !existsSync(layoutDir(root)) ||
+    !Array.isArray(installRegistry?.entries) ||
+    installRegistry.entries.length === 0 ||
+    !Array.isArray(tasks) ||
+    !session
+  );
+}
+
+function runOperatorCommand(args, root) {
+  const candidate = "enact-operator";
+  const candidateCwd = candidate.endsWith(".ts") || candidate.endsWith(".js") ? packageRoot() : root;
+  if (candidate.endsWith(".ts")) {
+    return execFileSync("node", ["--experimental-strip-types", candidate, ...args], {
+      cwd: candidateCwd,
+      encoding: "utf8",
+      timeout: 15000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  }
+  if (candidate.endsWith(".js")) {
+    return execFileSync("node", [candidate, ...args], {
+      cwd: candidateCwd,
+      encoding: "utf8",
+      timeout: 15000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  }
+  return execFileSync(candidate, args, {
+    cwd: root,
+    encoding: "utf8",
+    timeout: 15000,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+function runActivationEngine(root, prompt, payload) {
+  const script = join(packageRoot(), "runtime", "hooks", "resolveSkillActivation.mjs");
+  const input = JSON.stringify({
+    root,
+    prompt,
+    modelId: payload?.modelId ?? payload?.model_id ?? payload?.model,
+    headers: payload?.headers,
+  });
+  const output = execFileSync("node", [script], {
+    cwd: packageRoot(),
+    encoding: "utf8",
+    input,
+    timeout: 15000,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  return String(output).trim();
+}
+
+async function ensureBootstrap(root) {
+  const config = readWorkspaceConfig();
+  if (payload?.skip_bootstrap === true || config?.operator?.skip_hook_bootstrap === true) {
+    return { bootstrapped: false, skipped: true };
+  }
+  if (!needsBootstrap(root)) {
+    return { bootstrapped: false };
+  }
+  try {
+    const { applySetup } = await import(join(packageRoot(), "dist", "shared", "core", "bootstrap.js"));
+    applySetup({ root });
+    return { bootstrapped: true };
+  } catch (err) {
+    const stderr = err.stderr ? String(err.stderr).trim() : String(err.message ?? err);
+    return { bootstrapped: false, error: stderr };
+  }
+}
+
+const RUNTIME_CLASS_SKILLS = new Set(["autopilot", "ralph", "ultrawork", "team"]);
+
+function mcpHintForSkill(skill) {
+  const common = "If `operator_*` tools are not visible yet, call `tool_search` immediately to load the Enact Operator MCP namespace. If a namespace tool such as `mcp__enact_operator` is already visible, its nested `operator_*` functions are already callable and `tool_search` will only return the still-deferred subset. If the exact operator function you need is already present in the visible tool list, call it directly and skip `tool_search` for that name. Do not treat `tool_search` results as the full operator surface when a namespace is already present. Use Operator MCP tools before the `enact-operator` CLI.";
+  switch (skill) {
+    case "autopilot":
+        return `${common} If no external task id is linked, local Operator task discipline is mandatory: autopilot owns a local task. Read \`operator_task_list\` immediately and keep that task current instead of deferring tracking to AzDO. Search for \`operator_autopilot_status operator_task_list operator_operator_snapshot operator_hud operator_resume_from_repo_truth\`. Start with \`operator_autopilot_status\`, then \`operator_task_list\`, then continue with \`operator_autopilot_*\`, \`operator_operator_snapshot\`, \`operator_hud\`, and \`operator_resume_from_repo_truth\`.`;
+    case "ralph":
+        return `${common} If no external task id is linked, local Operator task discipline is mandatory: Ralph owns a local task. Read \`operator_task_list\` immediately and keep that task current instead of deferring tracking to AzDO. Search for \`operator_ralph_status operator_task_list operator_doctor operator_audit_provider_boundary operator_resume_from_repo_truth operator_hud\`. Start with \`operator_ralph_status\`, then \`operator_task_list\`, inspect the actual gates present in Ralph state, then continue with \`operator_ralph_*\` and only the gate tools that match the active gate set.`;
+    case "ultrawork":
+        return `${common} If no external task id is linked, local Operator task discipline is mandatory: ultrawork owns a local task. Read \`operator_task_list\` immediately and keep that task current instead of deferring tracking to AzDO. Search for \`operator_ultrawork_status operator_task_list operator_inbox_list operator_reviews_list operator_hud\`. Start with \`operator_ultrawork_status\`, then continue with \`operator_ultrawork_*\`, \`operator_task_list\`, \`operator_inbox_list\`, \`operator_reviews_list\`, and \`operator_hud\`.`;
+    case "ultragoal":
+        return `Use Operator MCP tools before the \`enact-operator\` CLI. These direct operator functions should already be visible in the callable tool list for this skill: \`mcp__enact_operator__operator_ultragoal_update\`, \`mcp__enact_operator__operator_session_start\`, \`mcp__enact_operator__operator_ultrawork_start\`, \`mcp__enact_operator__operator_ultrawork_link_plan\`, \`mcp__enact_operator__operator_ultrawork_link_task\`, \`mcp__enact_operator__operator_ultrawork_verify\`, \`mcp__enact_operator__operator_ultrawork_status\`, \`mcp__enact_operator__operator_ultrawork_complete\`, \`mcp__enact_operator__operator_contract_parity_run\`, \`mcp__enact_operator__operator_operator_snapshot\`, \`mcp__enact_operator__operator_hud\`, \`mcp__enact_operator__operator_workflow_reconcile\`, and \`mcp__enact_operator__operator_task_list\`. Call those direct names first. Do not call \`tool_search\` for these names unless one of those exact functions is absent from the visible tool list. If no external task id is linked, local Operator task discipline is mandatory: the active ultrawork burst under ultragoal owns a local task. Read \`operator_task_list\` immediately and keep that task current instead of deferring tracking to AzDO. Start with \`operator_ultragoal_update\`, then \`operator_session_start\`, then \`operator_ultrawork_start\`, then continue with the relevant \`operator_ultrawork_*\` tools, \`operator_task_list\`, \`operator_contract_parity_run\`, \`operator_operator_snapshot\`, \`operator_hud\`, and \`operator_workflow_reconcile\`.`;
+    case "team":
+        return `${common} When no external task id exists, local Operator task discipline is mandatory: queue the first local task immediately, then claim and review by local \`taskId\` instead of deferring tracking to AzDO. Search for \`operator_team_status operator_team_init operator_team_queue operator_task_list operator_team_claim operator_team_complete operator_team_review operator_team_inbox operator_team_logs operator_hud\`. Use MCP only. Important: for every \`operator_team_*\` call, \`root\` must be the repository root that owns \`.enact/operator\`, not a task subdirectory. Treat task folders as the code workspace, not the Operator state root. During bootstrap, do not fan out parallel MCP calls; confirm \`operator_team_status\` / \`operator_team_init\` sequentially first, then proceed to queue/claim/complete/review.`;
+    case "setup":
+      return `${common} Search for \`operator_setup operator_install_registry operator_doctor operator_audit_replacement_readiness\`. Prefer \`operator_setup\` for runtime layout only. Plugin install, hook registration, MCP registration, status, enable/disable, and uninstall are owned by \`enact-extensions install enact-operator --platform <surface>\`.`;
+    default:
+      return `${common} Search for the relevant \`operator_*\` tools for this skill and use CLI only when no MCP equivalent exists.`;
+  }
+}
+
+function buildAdditionalContext(result, repoRoot) {
+  const mcpHint = mcpHintForSkill(result.intent.skill);
+  const taskWorkspaceMatch = typeof result.intent.goal === 'string'
+    ? result.intent.goal.match(/Work only inside\s+(\S+)/i)
+    : null;
+  const taskWorkspace = taskWorkspaceMatch ? taskWorkspaceMatch[1] : null;
+  const operatorRoot = chooseOperatorRoot(repoRoot, result.intent.goal ?? '', result.intent.skill);
+  const continuationState = readJson(layoutPath(operatorRoot, "state", "continuation-state.json"), null);
+  let continuationHint = continuationState?.status === 'blocked' && continuationState?.resumeHint
+    ? ` Resume hint: ${continuationState.resumeHint}`
+    : '';
+  if (continuationState?.status === 'blocked' && findHeadQueuedFollowUp(operatorRoot)) {
+    continuationHint += ' Queued operator follow-up: check operator_continuation_followup_status or complete work then operator_continuation_followup_ack.';
+  }
+  if (result.decision === 'retarget' && result.requiredAction) {
+    return `Active ${result.intent.skill} goal differs from the new explicit ask. Do not silently reuse it. ${mcpHint}${continuationHint} Next action: ${result.requiredAction.tool}.`;
+  }
+  if (result.decision === 'reject') {
+    return `Ignored ${result.intent.skill} activation. ${result.reason ?? 'The prompt is not a durable execution goal.'} ${mcpHint}${continuationHint}`;
+  }
+  if (result.alreadyActive) {
+    const name = result.intent.skill.charAt(0).toUpperCase() + result.intent.skill.slice(1);
+    return `${name} already active. ${mcpHint}${continuationHint}`;
+  }
+  if (result.needsGoal) {
+    const name = result.intent.skill.charAt(0).toUpperCase() + result.intent.skill.slice(1);
+    return `${name} invoked without goal — please supply one. ${mcpHint}${continuationHint}`;
+  }
+  if (result.error) {
+    return `Skill activation error (${result.intent.skill}): ${result.error.slice(0, 200)} ${mcpHint}${continuationHint}`;
+  }
+  const variantSnippet =
+    result.selectedVariant && result.selectedVariant !== 'SKILL' && typeof result.selectedPromptContent === 'string'
+      ? ` Selected variant: ${result.selectedVariant} (${result.selectedPromptPath}).\n\n${result.selectedPromptContent}`
+      : '';
+  if (result.startedStateId) {
+    const name = result.intent.skill.charAt(0).toUpperCase() + result.intent.skill.slice(1);
+    const goalSnippet = result.intent.goal ? ` "${result.intent.goal.slice(0, 80)}"` : "";
+    if (result.intent.skill === 'team') {
+      const workspaceNote = taskWorkspace
+        ? ` Task workspace: ${taskWorkspace}.`
+        : '';
+      return `Activated ${name}:${goalSnippet} ${mcpHint}${continuationHint} Operator root: ${operatorRoot}.${workspaceNote} Immediate next MCP sequence: 1) operator_team_status { root: "${operatorRoot}" } 2) operator_team_queue { root: "${operatorRoot}", title: "<first concrete slice>" } 3) operator_team_claim { root: "${operatorRoot}", taskId: "<queued id>", executorId: "executor" }. Do not pass the task workspace as MCP root.${variantSnippet}`;
+    }
+    return `Activated ${name}:${goalSnippet} ${mcpHint}${continuationHint}${variantSnippet}`;
+  }
+  if (result.activated) {
+    const name = result.intent.skill.charAt(0).toUpperCase() + result.intent.skill.slice(1);
+    const goalSnippet = result.intent.goal ? ` "${result.intent.goal.slice(0, 80)}"` : "";
+    if (RUNTIME_CLASS_SKILLS.has(result.intent.skill)) {
+      return `Activated ${name}:${goalSnippet} ${mcpHint}${continuationHint}${variantSnippet}`;
+    }
+    return `Skill ${result.intent.skill} invoked. ${mcpHint}${continuationHint}${variantSnippet}`;
+  }
+  return `Skill ${result.intent.skill} activation recorded. ${mcpHint}${continuationHint}${variantSnippet}`;
+}
+
+const payload = readStdin();
+const startedAt = Date.now();
+const completeHook = registerHookFailureTrap({
+  payload,
+  hookEvent: "UserPromptSubmit",
+  startedAt,
+});
+const prompt = payload?.prompt ?? payload?.user_prompt ?? payload?.input ?? payload?.message ?? "";
+const repoRoot = rootDirFrom(payload?.cwd ?? process.cwd());
+const promptSkillIntent = (() => {
+  const match = String(prompt).match(/\$(?:enact-operator:)?([a-z][a-z0-9-]*)/i);
+  return match ? match[1].toLowerCase() : '';
+})();
+const root = chooseOperatorRoot(repoRoot, String(prompt), promptSkillIntent);
+const operatorLayout = layoutDir(root);
+mkdirSync(layoutPath(root, "logs"), { recursive: true });
+appendFileSync(
+  layoutPath(root, "logs", "hooks.log"),
+  `${new Date().toISOString()} UserPromptSubmit ${String(prompt).slice(0, 160)}\n`,
+  "utf8",
+);
+touchContinuationActivity(root, "user-prompt-submit");
+
+const memoryPath = layoutPath(root, "memory", "project.json");
+const current = readJson(memoryPath, {
+  namespace: "project",
+  summary: "",
+  facts: [],
+  updatedAt: new Date().toISOString(),
+});
+const nextFacts = [...(current.facts ?? []), `Prompt: ${String(prompt).slice(0, 120)}`].slice(-12);
+writeJson(memoryPath, {
+  ...current,
+  facts: nextFacts,
+  updatedAt: new Date().toISOString(),
+});
+
+const bootstrap = await ensureBootstrap(root);
+let result = null;
+
+if (bootstrap.error) {
+  // If bootstrap failed we cannot safely execute any state mutations.
+  const activationPayload = runActivationEngine(root, String(prompt), payload);
+  if (activationPayload && activationPayload !== "null") {
+    try {
+      result = JSON.parse(activationPayload);
+      result.error = `bootstrap failed: ${bootstrap.error}`;
+    } catch {
+      result = null;
+    }
+  }
+} else {
+  const activationPayload = runActivationEngine(root, String(prompt), payload);
+  if (activationPayload && activationPayload !== "null") {
+    try {
+      result = JSON.parse(activationPayload);
+    } catch {
+      result = null;
+    }
+  }
+}
+
+if (result) {
+  const contextNote = buildAdditionalContext(result, repoRoot);
+  await emitHookFired({
+    payload,
+    hookEvent: "UserPromptSubmit",
+    outcome: "noop",
+    latencyMs: Date.now() - startedAt,
+  });
+  if (readHooksVerbose(root)) verboseLog("user-prompt-submit", `skill intent detected: ${result.intent?.skill ?? "unknown"} — context injected`);
+  completeHook();
+  process.stdout.write(
+    JSON.stringify({
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "UserPromptSubmit",
+        additionalContext: contextNote,
+      },
+    }),
+  );
+} else {
+  await emitHookFired({
+    payload,
+    hookEvent: "UserPromptSubmit",
+    outcome: "noop",
+    latencyMs: Date.now() - startedAt,
+  });
+  if (readHooksVerbose(root)) verboseLog("user-prompt-submit", "no-op (no skill intent detected, prompt passed through)");
+  completeHook();
+  process.stdout.write(JSON.stringify({ continue: true }));
+}

package/runtime/hooks/layout-dir.mjs

@@ -0,0 +1,2 @@
+export * from "./shared/layout-dir.mjs";
+