sentinelayer-cli 0.22.0 → 0.24.0

package/README.md

@@ -101,6 +101,28 @@ Inputs for non-interactive mode:
 
 ## Multi-Agent Session Workflow
 
+Create a managed session (the golden path — one command):
+
+```bash
+sl session start --title "my room" --force-new
+```
+
+`session start` resumes this workspace's most recent active session when it was
+active within the last hour (`--force-new` always mints a fresh one) and spawns
+the **detached Senti daemon** that manages the room — agent greetings, mention
+routing, recaps, durable checkpoints — surviving your terminal. `--no-daemon`
+opts out; `sl session daemon <id>` runs the manager in the foreground. One
+daemon per session is enforced via `senti-daemon.json` in the session directory
+(logs in `senti-daemon.log` next to it), and the daemon exits on its own when
+the session expires.
+
+Then point your agents at it:
+
+```bash
+sl session join <session-id> --agent <agent-name>
+sl session say <session-id> "status: starting on auth middleware" --agent <agent-name>
+```
+
 Sentinelayer includes a deterministic session coordination surface for multi-agent coding loops:
 
 - session event stream and replay (`start`, `join`, `say`, `read`, `status`, `leave`, `list`, `kill`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sentinelayer-cli",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Scaffold Sentinelayer spec/prompt/guide artifacts with secure browser auth and token bootstrap.",
   "type": "module",
   "scripts": {

package/src/audit/orchestrator.js

@@ -753,6 +753,23 @@ export async function runAuditOrchestrator({
     });
     const agentPath = path.join(agentsDirectory, `${agent.id}.json`);
     await fsp.writeFile(agentPath, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
+    emitAuditLifecycleEvent(
+      onEvent,
+      runId,
+      "agent_complete",
+      {
+        phase: "dispatch",
+        agentId: agent.id,
+        persona: agent.persona,
+        domain: agent.domain,
+        status: agentStatus,
+        findingCount: findings.length,
+        summary,
+        confidence,
+        durationMs: result.durationMs,
+      },
+      `${agent.id} persona complete: ${findings.length} finding(s).`
+    );
     return {
       ...result,
       artifactPath: agentPath,

package/src/commands/audit.js

@@ -9,6 +9,7 @@ import { writeAuditComparisonArtifact } from "../audit/replay.js";
 import { loadAuditRegistry, selectAuditAgents } from "../audit/registry.js";
 import { resolveOutputRoot } from "../config/service.js";
 import { createAgentEvent } from "../events/schema.js";
+import { createAuditSessionReporter, resolveAuditSessionId } from "../session/audit-reporter.js";
 import { buildLegacyArgs } from "./legacy-args.js";
 
 function shouldEmitJson(options, command) {
@@ -89,6 +90,11 @@ export function registerAuditCommand(program, invokeLegacy) {
     .option("--no-seed-from-deterministic", "Run personas without deterministic baseline or specialist seed findings")
     .option("--reuse-omargate <runId>", "Reuse deterministic findings from an OmarGate run id or latest")
     .option("--stream", "Emit NDJSON agent events to stdout")
+    .option(
+      "--session <id>",
+      "Senti session id to relay audit progress into (defaults to the workspace's most recent active session)"
+    )
+    .option("--no-session", "Disable senti session progress relay")
     .option("--json", "Emit machine-readable output")
     .action(async (targetPathArg, options, command) => {
       const emitJson = shouldEmitJson(options, command);
@@ -105,18 +111,49 @@ export function registerAuditCommand(program, invokeLegacy) {
         throw new Error("No agents selected for audit run.");
       }
 
-      const result = await runAuditOrchestrator({
+      const auditSessionId = await resolveAuditSessionId({
+        targetPath,
+        explicitSessionId: typeof options.session === "string" ? options.session : "",
+        disabled: options.session === false,
+      });
+      const sessionReporter = createAuditSessionReporter({
+        sessionId: auditSessionId,
         targetPath,
-        agents: selected.selected,
-        maxParallel: parseMaxParallel(options.maxParallel),
-        outputDir: options.outputDir,
-        dryRun: Boolean(options.dryRun),
-        refreshIngest: Boolean(options.refresh),
-        isolation: parseIsolationMode(options.isolation),
-        seedFromDeterministic: options.seedFromDeterministic !== false,
-        reuseOmarGate: options.reuseOmargate,
-        onEvent: buildAuditOrchestratorEventHandler(emitStream),
       });
+      const streamHandler = buildAuditOrchestratorEventHandler(emitStream);
+      const onEvent =
+        streamHandler || sessionReporter
+          ? (evt) => {
+              if (streamHandler) {
+                streamHandler(evt);
+              }
+              if (sessionReporter) {
+                sessionReporter.handleEvent(evt);
+              }
+            }
+          : null;
+
+      let result;
+      try {
+        result = await runAuditOrchestrator({
+          targetPath,
+          agents: selected.selected,
+          maxParallel: parseMaxParallel(options.maxParallel),
+          outputDir: options.outputDir,
+          dryRun: Boolean(options.dryRun),
+          refreshIngest: Boolean(options.refresh),
+          isolation: parseIsolationMode(options.isolation),
+          seedFromDeterministic: options.seedFromDeterministic !== false,
+          reuseOmarGate: options.reuseOmargate,
+          onEvent,
+        });
+      } catch (error) {
+        if (sessionReporter) {
+          await sessionReporter.failed(error);
+        }
+        throw error;
+      }
+      const sessionRelay = sessionReporter ? await sessionReporter.completed(result) : null;
 
       const payload = {
         command: "audit",
@@ -144,12 +181,23 @@ export function registerAuditCommand(program, invokeLegacy) {
         ddPackageFindingsPath: result.ddPackage?.findingsIndexPath || "",
         ddPackageSummaryPath: result.ddPackage?.executiveSummaryPath || "",
         ingestRefresh: result.ingest?.refresh || null,
+        sessionId: auditSessionId || "",
+        sessionRelay: sessionRelay || null,
       };
 
       if (emitJson) {
         console.log(JSON.stringify(payload, null, 2));
       } else if (!emitStream) {
         printAuditSummary(result);
+        if (auditSessionId) {
+          console.log(
+            pc.gray(
+              `Senti session: ${auditSessionId} (posted ${sessionRelay?.posted ?? 0} update(s)${
+                sessionRelay?.failed ? `, ${sessionRelay.failed} failed` : ""
+              })`
+            )
+          );
+        }
       }
 
       if (result.summary.blocking) {

package/src/commands/guide.js

@@ -4,6 +4,13 @@ import path from "node:path";
 
 import pc from "picocolors";
 
+import {
+  createMultiProviderApiClient,
+  resolveApiKey,
+  resolveModel,
+  resolveProvider,
+} from "../ai/client.js";
+import { enrichGuideTickets } from "../guide/enrich.js";
 import {
   defaultGuideExportFileName,
   generateBuildGuide,
@@ -12,6 +19,40 @@ import {
 } from "../guide/generator.js";
 import { renderTerminalMarkdown } from "../ui/markdown.js";
 
+// Optionally split each phase into per-PR tickets with an LLM. Best-effort:
+// any failure leaves the deterministic tickets untouched. Returns the number
+// of phases enriched (0 when disabled or unavailable).
+async function maybeEnrichGuide(guideDoc, options) {
+  if (!options || !options.enrich) return 0;
+  try {
+    const provider = resolveProvider({ provider: options.provider });
+    const model = resolveModel({ provider, model: options.model });
+    const apiKey = resolveApiKey({ provider, explicitApiKey: options.apiKey });
+    if (!apiKey) {
+      console.error(
+        pc.yellow(`! --enrich skipped: no API key for provider '${provider}'. Set the provider key or pass --api-key.`)
+      );
+      return 0;
+    }
+    const limits = {};
+    if (options.maxPhases) limits.maxPhases = Number(options.maxPhases);
+    if (options.maxPrsPerPhase) limits.maxTicketsPerPhase = Number(options.maxPrsPerPhase);
+    const { tickets, enrichedPhases } = await enrichGuideTickets({
+      guide: guideDoc,
+      client: createMultiProviderApiClient(),
+      provider,
+      model,
+      apiKey,
+      limits,
+    });
+    if (enrichedPhases > 0) guideDoc.tickets = tickets;
+    return enrichedPhases;
+  } catch (error) {
+    console.error(pc.yellow(`! --enrich failed, using deterministic tickets: ${error?.message || error}`));
+    return 0;
+  }
+}
+
 function shouldEmitJson(options, command) {
   const local = Boolean(options && options.json);
   const globalFromCommand =
@@ -101,6 +142,12 @@ export function registerGuideCommand(program) {
     .option("--path <path>", "Target workspace path", ".")
     .option("--spec-file <path>", "Spec file path relative to --path")
     .option("--output-file <path>", "Output export file path relative to --path")
+    .option("--enrich", "Split each phase into per-PR tickets with an LLM (opt-in, capped)")
+    .option("--provider <provider>", "LLM provider for --enrich (openai|anthropic|google)")
+    .option("--model <model>", "LLM model for --enrich")
+    .option("--api-key <key>", "Explicit API key for --enrich (else from env)")
+    .option("--max-phases <n>", "Cap how many phases --enrich expands")
+    .option("--max-prs-per-phase <n>", "Cap PRs per phase for --enrich")
     .option("--json", "Emit machine-readable output")
     .action(async (options, command) => {
       const targetPath = path.resolve(process.cwd(), String(options.path || "."));
@@ -116,6 +163,7 @@ export function registerGuideCommand(program) {
         projectPath: targetPath,
         specPath,
       });
+      const enrichedPhases = await maybeEnrichGuide(guideDoc, options);
       const exportBody = renderGuideExport({ format, guide: guideDoc });
 
       await fsp.mkdir(path.dirname(outputPath), { recursive: true });
@@ -128,6 +176,7 @@ export function registerGuideCommand(program) {
         specPath,
         outputPath,
         issueCount: guideDoc.tickets.length,
+        enrichedPhases,
       };
 
       if (shouldEmitJson(options, command)) {
@@ -139,6 +188,9 @@ export function registerGuideCommand(program) {
       console.log(pc.gray(`Format: ${format}`));
       console.log(pc.gray(`Output: ${outputPath}`));
       console.log(pc.gray(`Issues: ${guideDoc.tickets.length}`));
+      if (enrichedPhases > 0) {
+        console.log(pc.gray(`LLM-enriched phases: ${enrichedPhases}`));
+      }
     });
 
   guide