@orchestrator-claude/definitions 3.32.1 → 3.33.0

package/hooks/subagent-stop.ts

@@ -18,8 +18,8 @@ import {
   consumeInvocationState,
   completeAgentInvocation,
   isInvocationStateStale,
+  resolveAgentMemoryBaseDir,
 } from './lib/api-client.js';
-import { join } from 'node:path';
 import { createCheckpointIfNeeded } from './lib/git-checkpoint.js';
 import { appendObservation } from './lib/observations-helper.js';
 
@@ -98,7 +98,9 @@ async function main(): Promise<void> {
   // 4. Write Tier B observation (fail-open)
   try {
     const sessionId = getField(stdin, 'session_id') || getField(stdin, 'claude_session_id') || '';
-    const memoryBaseDir = join(process.cwd(), '.claude', 'agent-memory');
+    // RFC-040 Operator Multi-Project — Slice 5 (C5): resolves under the
+    // project root walked up from cwd (falls back to cwd when unregistered).
+    const memoryBaseDir = resolveAgentMemoryBaseDir(process.cwd());
     appendObservation(memoryBaseDir, agentType, {
       timestamp: new Date().toISOString(),
       session_id: sessionId,

package/hooks/user-prompt.mjs

@@ -0,0 +1,329 @@
+import { createRequire as __createRequireShim } from 'node:module'; const require = __createRequireShim(import.meta.url);
+
+// hooks/lib/api-client.ts
+import { readFileSync, writeFileSync, mkdirSync, statSync, unlinkSync, readdirSync } from "node:fs";
+import { join as join2, dirname as dirname2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../project-root-resolver/dist/index.js
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+function resolveProjectRoot(cwd, sentinel = ".orchestrator") {
+  let currentDir = cwd;
+  for (; ; ) {
+    if (existsSync(join(currentDir, sentinel))) {
+      return currentDir;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+// hooks/lib/api-client.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+var PROJECT_ROOT = join2(__dirname, "..", "..", "..");
+var STATE_DIR = join2(PROJECT_ROOT, ".orchestrator", ".state");
+var JWT_CACHE = join2(STATE_DIR, "jwt-token");
+var DEBUG_LOG = join2(STATE_DIR, "hook-debug.log");
+mkdirSync(STATE_DIR, { recursive: true });
+var API_URL = process.env.ORCHESTRATOR_API_URL || "http://localhost:3001";
+var AUTH_EMAIL = process.env.ORCHESTRATOR_ADMIN_EMAIL || process.env.ORCHESTRATOR_AUTH_EMAIL || "system@orchestrator.local";
+var AUTH_PASSWORD = process.env.ORCHESTRATOR_ADMIN_PASSWORD || process.env.ORCHESTRATOR_AUTH_PASSWORD || "system123";
+var PROJECT_ID = process.env.ORCHESTRATOR_PROJECT_ID || "";
+function resolveHookProjectRoot(cwd) {
+  return resolveProjectRoot(cwd);
+}
+var projectIdResolutionAttempted = false;
+async function ensureProjectIdResolved(token) {
+  if (PROJECT_ID || projectIdResolutionAttempted) return;
+  projectIdResolutionAttempted = true;
+  try {
+    const rootPath = resolveHookProjectRoot(process.cwd());
+    if (rootPath === null) {
+      log(
+        "API-CLIENT",
+        "ensureProjectIdResolved: cwd not registered (.orchestrator sentinel not found) \u2014 skipping"
+      );
+      return;
+    }
+    const resolved = await resolveProjectIdByPath(rootPath, token);
+    if (resolved) {
+      PROJECT_ID = resolved;
+      log(
+        "API-CLIENT",
+        `ensureProjectIdResolved: resolved projectId=${resolved} rootPath=${rootPath}`
+      );
+    } else {
+      log(
+        "API-CLIENT",
+        `ensureProjectIdResolved: rootPath=${rootPath} not registered to any project \u2014 skipping`
+      );
+    }
+  } catch (err) {
+    log(
+      "API-CLIENT",
+      `ensureProjectIdResolved: unexpected failure \u2014 ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function log(prefix, msg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "Z");
+  try {
+    const line = `[${ts}] ${prefix}: ${msg}
+`;
+    writeFileSync(DEBUG_LOG, line, { flag: "a" });
+  } catch {
+  }
+}
+function getCachedToken() {
+  try {
+    const stat = statSync(JWT_CACHE);
+    const ageMs = Date.now() - stat.mtimeMs;
+    if (ageMs < 35e5) {
+      return readFileSync(JWT_CACHE, "utf-8").trim();
+    }
+  } catch {
+  }
+  return null;
+}
+async function login() {
+  try {
+    const resp = await fetch(`${API_URL}/api/v1/auth/login`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Project-ID": PROJECT_ID
+      },
+      body: JSON.stringify({ email: AUTH_EMAIL, password: AUTH_PASSWORD }),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    const token = data.accessToken || data.data?.accessToken || "";
+    if (token) {
+      writeFileSync(JWT_CACHE, token);
+    }
+    return token || null;
+  } catch {
+    return null;
+  }
+}
+async function getToken() {
+  const token = getCachedToken() || await login();
+  if (token) {
+    await ensureProjectIdResolved(token);
+  }
+  return token;
+}
+async function apiGet(path, token, timeoutMs = 5e3) {
+  try {
+    const resp = await fetch(`${API_URL}${path}`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "X-Project-ID": PROJECT_ID
+      },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!resp.ok) return null;
+    return await resp.json();
+  } catch {
+    return null;
+  }
+}
+async function apiPost(path, token, body, timeoutMs = 5e3) {
+  try {
+    const resp = await fetch(`${API_URL}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+        "X-Project-ID": PROJECT_ID
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!resp.ok) return null;
+    return await resp.json();
+  } catch {
+    return null;
+  }
+}
+async function resolveProjectIdByPath(rootPath, token) {
+  const resp = await apiGet(
+    `/api/v1/projects/resolve?rootPath=${encodeURIComponent(rootPath)}`,
+    token
+  );
+  return resp?.projectId ?? null;
+}
+async function getActiveWorkflow() {
+  const token = await getToken();
+  if (!token) return null;
+  for (const status of ["in_progress", "awaiting_agent", "awaiting_approval"]) {
+    const resp = await apiGet(
+      `/api/v1/workflows?status=${status}&limit=1`,
+      token,
+      3e3
+    );
+    const list = resp?.data || (Array.isArray(resp) ? resp : null);
+    const wf = list?.[0];
+    if (wf?.id) return wf;
+  }
+  return null;
+}
+async function getNextAction(workflowId) {
+  const token = await getToken();
+  if (!token) return null;
+  return apiGet(`/api/v1/workflows/${workflowId}/pending-action`, token);
+}
+async function detectWorkflow(prompt) {
+  const token = await getToken();
+  if (!token) return null;
+  return apiPost(`/api/v1/workflows/detect`, token, { prompt }, 3e3);
+}
+var LAST_COMPLETED_FILE = join2(STATE_DIR, "last-completed-workflow.json");
+var LAST_COMPLETED_TTL_MS = 60 * 60 * 1e3;
+var INVOCATIONS_DIR = join2(STATE_DIR, "invocations");
+var INVOCATION_STATE_TTL_MS = 4 * 60 * 60 * 1e3;
+var DISPATCH_INTENT_DIR = join2(STATE_DIR, "dispatch-intent");
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf-8").trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function getField(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return "";
+    current = current[part];
+  }
+  return current != null ? String(current) : "";
+}
+function outputContext(hookEvent, context) {
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: hookEvent,
+        additionalContext: context
+      }
+    })
+  );
+}
+
+// hooks/lib/sprint-context.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "node:fs";
+import { join as join3, dirname as dirname3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname3(__filename2);
+var PROJECT_ROOT2 = join3(__dirname2, "..", "..", "..");
+var SPRINT_CONTEXT_DIR = join3(PROJECT_ROOT2, ".claude", "sprint-context");
+function contextPath(workflowId) {
+  return join3(SPRINT_CONTEXT_DIR, `${workflowId}.json`);
+}
+function readSprintContext(workflowId) {
+  try {
+    const filePath = contextPath(workflowId);
+    if (!existsSync2(filePath)) {
+      return null;
+    }
+    const raw = readFileSync2(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// hooks/user-prompt.ts
+var HOOK = "USER-PROMPT";
+async function main() {
+  log(HOOK, "UserPromptSubmit triggered");
+  const stdin = await readStdin();
+  const workflow = await getActiveWorkflow();
+  if (!workflow) {
+    const prompt2 = getField(stdin, "prompt");
+    if (!prompt2) {
+      log(HOOK, "empty prompt, silence");
+      return;
+    }
+    const detection = await detectWorkflow(prompt2);
+    if (!detection) {
+      log(HOOK, "detect API failed/timeout, silence (fail-open)");
+      return;
+    }
+    const { workflowType, confidence, suggestedMode } = detection;
+    log(HOOK, `detected type=${workflowType} confidence=${confidence} mode=${suggestedMode}`);
+    if (workflowType === "interactive_analysis") {
+      outputContext(
+        "UserPromptSubmit",
+        [
+          "[ORCHESTRATOR] This looks like an analytical/design request. How would you like to proceed?",
+          "(a) Continue as a free conversation (no workflow)",
+          "(b) Start an interactive_analysis workflow for structured exploration (cyclic phases: research \u2192 discuss \u2192 analyze)",
+          "",
+          'If you choose (b), I will call: mcp__orchestrator-tools__startWorkflow({ type: "interactive_analysis", prompt: "..." })'
+        ].join("\n")
+      );
+      return;
+    }
+    if (confidence >= 0.7) {
+      const mode = suggestedMode || "standard";
+      outputContext(
+        "UserPromptSubmit",
+        `[ORCHESTRATOR] Detected: ${workflowType} workflow (confidence: ${confidence}, suggested mode: ${mode}).
+To start: mcp__orchestrator-tools__startWorkflow({ type: "${workflowType}", prompt: "...", mode: "${mode}" })
+Or continue without a workflow if this is exploratory.`
+      );
+      return;
+    }
+    if (confidence >= 0.5) {
+      outputContext(
+        "UserPromptSubmit",
+        `[ORCHESTRATOR] Hint: this might be a ${workflowType} task. Consider starting a workflow if you plan to write code.`
+      );
+      return;
+    }
+    log(HOOK, `Tier 4 silence (confidence=${confidence} < 0.5)`);
+    return;
+  }
+  const prompt = getField(stdin, "prompt");
+  if (/brainstorm/i.test(prompt)) {
+    try {
+      const sprintCtx = readSprintContext(workflow.id);
+      if (sprintCtx) {
+        const previousSummary = sprintCtx.previousSprints.length === 0 ? "none" : sprintCtx.previousSprints.map((s) => `S${s.index}(${s.status})`).join(", ");
+        const brainstormContext = [
+          `[PARENT-DOC-CONTEXT] parentDocument=${sprintCtx.parentDocument} | sprint=${sprintCtx.sprintIndex} | scope=${sprintCtx.sprintScope} | previousSprints=${previousSummary}`,
+          `[ORCHESTRATOR] Include parent document context in this brainstorm. Read the RFC for background.`
+        ].join("\n");
+        log(HOOK, `brainstorm detected, injecting sprint context for workflow=${workflow.id}`);
+        outputContext("UserPromptSubmit", brainstormContext);
+        return;
+      }
+    } catch {
+      log(HOOK, "brainstorm context read failed, falling through to standard injection");
+    }
+  }
+  const action = await getNextAction(workflow.id);
+  let context;
+  if (action?.hasAction && action.pendingAction) {
+    context = `[ORCHESTRATOR] Active workflow: ${workflow.id}. Next: invoke '${action.pendingAction.agent}' (${action.pendingAction.status}).`;
+  } else {
+    context = `[ORCHESTRATOR] Active workflow: ${workflow.id}. No pending actions.`;
+  }
+  log(HOOK, `workflow=${workflow.id} hasAction=${action?.hasAction}`);
+  outputContext("UserPromptSubmit", context);
+}
+main().catch(() => process.exit(0));