@abelxiaoxing/cadence 1.0.1 → 1.0.3

package/src/scheduler.ts

@@ -34,6 +34,16 @@ export interface SchedulerOptions<T = unknown> {
   ): Promise<T>;
 }
 
+export interface ConflictDeclaration {
+  taskId: string;
+  requestId?: string;
+  read: string[];
+  write: string[];
+  conflicts: string[];
+  resources: string[];
+  verificationLocks: string[];
+}
+
 type EntryState = "queued" | "running" | TerminalStatus;
 
 interface Entry<T> {
@@ -53,34 +63,63 @@ function intersects(left: string[], right: string[]): boolean {
   return left.some((path) => right.includes(path));
 }
 
+function pathsOverlap(left: string, right: string): boolean {
+  return (
+    left === "." ||
+    right === "." ||
+    left === right ||
+    left.startsWith(`${right}/`) ||
+    right.startsWith(`${left}/`)
+  );
+}
+
+function pathSetsOverlap(left: string[], right: string[]): boolean {
+  return left.some((a) => right.some((b) => pathsOverlap(a, b)));
+}
+
 function conflictEdgeMatches(
   conflicts: string[],
-  other: RequestEnvelope,
+  other: ConflictDeclaration,
 ): boolean {
   return conflicts.some(
     (edge) =>
-      edge === other.id ||
-      other.declared.read.includes(edge) ||
-      other.declared.write.includes(edge),
+      edge === other.taskId ||
+      edge === other.requestId ||
+      other.read.some((path) => pathsOverlap(edge, path)) ||
+      other.write.some((path) => pathsOverlap(edge, path)),
   );
 }
 
-/** True when two declared envelopes cannot be active at the same time. */
+function requestConflictOf(request: RequestEnvelope): ConflictDeclaration {
+  return {
+    taskId: request.taskId ?? request.id,
+    requestId: request.id,
+    read: request.declared.read,
+    write: request.declared.write,
+    conflicts: request.declared.conflicts,
+    resources: request.declared.resources,
+    verificationLocks: request.declared.verificationLock
+      ? [request.declared.verificationLock]
+      : [],
+  };
+}
+
+/** True when two pure declarations cannot be active at the same time. */
 export function declarationsConflict(
-  left: RequestEnvelope,
-  right: RequestEnvelope,
+  left: ConflictDeclaration,
+  right: ConflictDeclaration,
 ): boolean {
-  const a = left.declared;
-  const b = right.declared;
-  if (intersects(a.write, b.write)) return true;
-  if (intersects(a.write, b.read) || intersects(a.read, b.write)) return true;
+  const a = left;
+  const b = right;
+  if (a.taskId === b.taskId) return true;
+  if (pathSetsOverlap(a.write, b.write)) return true;
+  if (pathSetsOverlap(a.write, b.read) || pathSetsOverlap(a.read, b.write)) {
+    return true;
+  }
   if (conflictEdgeMatches(a.conflicts, right)) return true;
   if (conflictEdgeMatches(b.conflicts, left)) return true;
   if (intersects(a.resources, b.resources)) return true;
-  return (
-    a.verificationLock !== undefined &&
-    a.verificationLock === b.verificationLock
-  );
+  return intersects(a.verificationLocks, b.verificationLocks);
 }
 
 function errorMessage(error: unknown): string {
@@ -234,7 +273,12 @@ export class Scheduler<T> {
 
   private hasActiveConflict(entry: Entry<T>): boolean {
     for (const activeEntry of this.active) {
-      if (declarationsConflict(entry.request, activeEntry.request)) {
+      if (
+        declarationsConflict(
+          requestConflictOf(entry.request),
+          requestConflictOf(activeEntry.request),
+        )
+      ) {
         return true;
       }
     }

package/src/scoped-tools.ts

@@ -31,6 +31,7 @@ export interface ScopedToolDef {
 
 interface Options {
   roots: string[];
+  allowedPaths?: string[];
   observer?: (obs: Observation) => void;
 }
 
@@ -38,7 +39,11 @@ type PathResult =
   | { ok: true; abs: string; rel: string }
   | { ok: false; error: string };
 
-function resolveScoped(roots: string[], input: unknown): PathResult {
+function resolveScoped(
+  roots: string[],
+  input: unknown,
+  allowedPaths?: string[],
+): PathResult {
   if (typeof input !== "string" || input.length === 0) {
     return { ok: false, error: "missing path" };
   }
@@ -54,11 +59,21 @@ function resolveScoped(roots: string[], input: unknown): PathResult {
   if (input.startsWith("./") || input.includes("//") || input.endsWith("/.")) {
     return { ok: false, error: "noncanonical path rejected" };
   }
+  let insideRoot = false;
   for (const root of roots) {
     const abs = resolve(root, input);
     const inside =
       abs === root || abs.startsWith(root.endsWith("/") ? root : `${root}/`);
     if (!inside) continue;
+    insideRoot = true;
+    if (
+      allowedPaths &&
+      !allowedPaths.some(
+        (allowed) => abs === allowed || abs.startsWith(`${allowed}/`),
+      )
+    ) {
+      continue;
+    }
     // Hidden directories are rejected unless the root itself is the hidden scope.
     const hiddenRoot =
       basename(realpathSync(root)) === ".git" ||
@@ -89,7 +104,12 @@ function resolveScoped(roots: string[], input: unknown): PathResult {
     }
     return { ok: true, abs: abs, rel: relative(root, abs) || "." };
   }
-  return { ok: false, error: "path is outside every approved root" };
+  return {
+    ok: false,
+    error: insideRoot
+      ? "path is outside the declared read/write scope"
+      : "path is outside every approved root",
+  };
 }
 
 function existsSync(p: string): boolean {
@@ -113,6 +133,7 @@ function utf8Text(abs: string): string | null {
 
 export function createScopedTools(opts: Options): ScopedToolDef[] {
   const roots = opts.roots.map((r) => resolve(r));
+  const allowedPaths = opts.allowedPaths?.map((p) => resolve(p));
   const observe = opts.observer ?? (() => {});
 
   const readTool: ScopedToolDef = {
@@ -120,7 +141,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
     description:
       "Read a regular UTF-8 text file within the approved scope (max 2,000 lines / 50 KiB).",
     async execute(params) {
-      const resolved = resolveScoped(roots, params.path);
+      const resolved = resolveScoped(roots, params.path, allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let st: Stats | undefined;
       try {
@@ -167,7 +188,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
           error: `pattern exceeds ${TOOL_LIMITS.maxGrepPattern} characters`,
         };
       }
-      const resolved = resolveScoped(roots, params.path ?? ".");
+      const resolved = resolveScoped(roots, params.path ?? ".", allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let regex: RegExp;
       try {
@@ -207,7 +228,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
     description:
       "List a directory within the approved scope (max 20,000 entries, stable code-unit order).",
     async execute(params) {
-      const resolved = resolveScoped(roots, params.path ?? ".");
+      const resolved = resolveScoped(roots, params.path ?? ".", allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let st: Stats | undefined;
       try {
@@ -236,7 +257,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
     description:
       "Recursively list paths within the approved scope (max 20,000 entries, stable code-unit order).",
     async execute(params) {
-      const resolved = resolveScoped(roots, params.path ?? ".");
+      const resolved = resolveScoped(roots, params.path ?? ".", allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let st: Stats | undefined;
       try {

package/src/subagent-activity.ts

@@ -10,7 +10,6 @@ import {
   visibleWidth,
 } from "@earendil-works/pi-tui";
 import type {
-  DispatchResult,
   RuntimeActivityEvent,
   RuntimeActivityObserver,
   RuntimeActivityState,
@@ -39,12 +38,12 @@ export interface EvidenceActivitySummary {
 export interface DiffActivitySummary {
   kind: "diff";
   summary: string;
-  nextStep: string;
   riskCount: number;
   retained: boolean;
 }
 
 export type ActivitySummary = EvidenceActivitySummary | DiffActivitySummary;
+export type ActivityTone = "success" | "warning" | "muted" | "error";
 
 export interface ActivityDisplay {
   version: 1;
@@ -54,6 +53,7 @@ export interface ActivityDisplay {
   phase: string;
   objective: string;
   state: TerminalActivityState;
+  tone: ActivityTone;
   elapsedMs: number;
   summary?: ActivitySummary;
   reason?: string;
@@ -217,14 +217,7 @@ function renderActivityLines(
     formatElapsed(elapsed),
   ].join(" · ");
   const second = `  ${sanitizeDisplayText(snapshot.objective, 240)}`;
-  const color =
-    snapshot.state === "completed"
-      ? "success"
-      : snapshot.state === "failed" || snapshot.state === "timed-out"
-        ? "error"
-        : snapshot.state === "cancelled"
-          ? "warning"
-          : "accent";
+  const color = "tone" in snapshot ? snapshot.tone : "accent";
   return [
     line(styled(theme, color, first), width),
     line(styled(theme, "muted", second), width),
@@ -311,7 +304,7 @@ export class ActivityInlineComponent implements Component {
         lines[1] = line(
           styled(
             this.theme,
-            "error",
+            this.display.tone,
             `  reason: ${sanitizeFailureReason(this.display.reason)}`,
           ),
           width,
@@ -323,7 +316,7 @@ export class ActivityInlineComponent implements Component {
     const detail =
       summary.kind === "evidence"
         ? `  evidence: ${summary.conclusions} conclusions · ${summary.citations} citations · ${summary.risks} risks · ${summary.blockingQuestions} blocking`
-        : `  diff: ${sanitizeDisplayText(summary.summary)} · next: ${sanitizeDisplayText(summary.nextStep)} · ${summary.riskCount} risks · retained: ${summary.retained ? "yes" : "no"}`;
+        : `  diff: ${sanitizeDisplayText(summary.summary)} · ${summary.riskCount} risks · retained: ${summary.retained ? "yes" : "no"}`;
     return [lines[0] ?? "", line(styled(this.theme, "muted", detail), width)];
   }
 
@@ -337,10 +330,14 @@ function asRecord(value: unknown): Record<string, unknown> | undefined {
 }
 
 export function summarizeDispatchResult(
-  result: DispatchResult,
+  result: unknown,
 ): ActivitySummary | undefined {
-  if (!result.ok) return undefined;
-  const value = asRecord(result.result);
+  const outer = asRecord(result);
+  if (!outer || outer.ok === false) return undefined;
+  const outcome = outer.ok === true ? asRecord(outer.result) : outer;
+  if (!outcome) return undefined;
+  const value =
+    outcome.kind === "candidate" ? asRecord(outcome.result) : outcome;
   if (!value) return undefined;
   if (
     value.kind === "evidence" &&
@@ -360,20 +357,41 @@ export function summarizeDispatchResult(
   if (
     value.kind === "diff" &&
     typeof value.summary === "string" &&
-    typeof value.nextStep === "string" &&
     Array.isArray(value.risks)
   ) {
     return {
       kind: "diff",
       summary: sanitizeDisplayText(value.summary),
-      nextStep: sanitizeDisplayText(value.nextStep),
       riskCount: value.risks.length,
-      retained: typeof result.resultId === "string",
+      retained:
+        typeof outer.resultId === "string" ||
+        typeof outcome.resultId === "string",
     };
   }
   return undefined;
 }
 
+function toneForResult(result: unknown): ActivityTone | undefined {
+  const outer = asRecord(result);
+  if (!outer || outer.ok === false) return undefined;
+  const value = outer.ok === true ? asRecord(outer.result) : outer;
+  switch (value?.kind) {
+    case "candidate":
+    case "applied":
+    case "completed":
+      return "success";
+    case "deferred":
+    case "retry":
+    case "checkpoint-required":
+      return "warning";
+    case "blocked":
+    case "cancelled":
+      return "muted";
+    default:
+      return undefined;
+  }
+}
+
 function terminalState(
   event: RuntimeActivityEvent,
 ): event is RuntimeActivityEvent & {
@@ -396,6 +414,12 @@ function displayFromEvent(
     phase: entry.phase,
     objective: sanitizeDisplayText(entry.objective),
     state: event.state as TerminalActivityState,
+    tone:
+      event.state === "failed" || event.state === "timed-out"
+        ? "error"
+        : event.state === "cancelled"
+          ? "muted"
+          : "success",
     elapsedMs,
     ...(reason === undefined ? {} : { reason: sanitizeFailureReason(reason) }),
   };
@@ -404,7 +428,7 @@ function displayFromEvent(
 export function createActivityDisplay(
   event: RuntimeActivityEvent,
   elapsedMs: number,
-  result?: DispatchResult,
+  result?: unknown,
 ): ActivityDisplay {
   const entry: ActivityEntry = {
     toolCallId: "",
@@ -419,7 +443,12 @@ export function createActivityDisplay(
   };
   const display = displayFromEvent(entry, event, elapsedMs);
   const summary = result ? summarizeDispatchResult(result) : undefined;
-  return summary ? { ...display, summary } : display;
+  const tone = result ? toneForResult(result) : undefined;
+  return {
+    ...display,
+    ...(tone === undefined ? {} : { tone }),
+    ...(summary === undefined ? {} : { summary }),
+  };
 }
 
 function activityPartial(display: ActivityDisplay | ActivitySnapshot): unknown {
@@ -538,15 +567,17 @@ export class ActivityController {
     this.syncUi();
   }
 
-  finalize(
-    toolCallId: string,
-    result: DispatchResult,
-  ): ActivityDisplay | undefined {
+  finalize(toolCallId: string, result: unknown): ActivityDisplay | undefined {
     const display = this.terminals.get(toolCallId);
     if (!display) return undefined;
     this.terminals.delete(toolCallId);
     const summary = summarizeDispatchResult(result);
-    return summary ? { ...display, summary } : display;
+    const tone = toneForResult(result);
+    return {
+      ...display,
+      ...(tone === undefined ? {} : { tone }),
+      ...(summary === undefined ? {} : { summary }),
+    };
   }
 
   getActiveEntries(): readonly ActivitySnapshot[] {

package/src/submit-tool.ts

@@ -1,6 +1,7 @@
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import {
+  type CandidateFailure,
   type DiffResult,
   type EvidenceResult,
   validateDiffResult,
@@ -36,7 +37,6 @@ const diffSchema = Type.Object({
   diff: Type.String(),
   expectedVerification: Type.String(),
   risks: Type.Array(Type.String()),
-  nextStep: Type.String(),
   contractCompliant: Type.Literal(true),
 });
 
@@ -63,11 +63,13 @@ export interface SubmitClassification {
 
 export function createSubmitTool(input: {
   requestId: string;
+  taskId?: string;
   role: string;
   phase: string;
   output: "evidence" | "diff";
 }) {
   let submitted: EvidenceResult | DiffResult | undefined;
+  let failure: CandidateFailure | undefined;
   let attempts = 0;
   let schema: "valid" | "invalid" = "invalid";
   const identity: IdentityOutcome = {
@@ -93,12 +95,14 @@ export function createSubmitTool(input: {
         identity.task = false;
         identity.phase = false;
         schema = "invalid";
+        failure = { kind: "artifact", code: "invalid-structural-result" };
         throw new Error("submitted result is not an object");
       }
       if (value.id !== input.requestId) identity.request = false;
       if (value.role !== input.role) identity.role = false;
       if (input.output === "diff") {
-        if (value.taskId !== input.requestId) identity.task = false;
+        if (value.taskId !== (input.taskId ?? input.requestId))
+          identity.task = false;
         if (value.phase !== input.phase) identity.phase = false;
       }
       const validation =
@@ -109,11 +113,17 @@ export function createSubmitTool(input: {
       const matches =
         identity.request && identity.role && identity.task && identity.phase;
       if (!validation.ok || !matches) {
+        failure =
+          validation.failure ??
+          ({ kind: "artifact", code: "invalid-structural-result" } as const);
         throw new Error(
           validation.reason ?? "submitted result identity does not match",
         );
       }
-      if (submitted) throw new Error("duplicate structural submission");
+      if (submitted) {
+        failure = { kind: "artifact", code: "invalid-structural-result" };
+        throw new Error("duplicate structural submission");
+      }
       submitted = structuredClone(value) as unknown as
         | EvidenceResult
         | DiffResult;
@@ -131,5 +141,7 @@ export function createSubmitTool(input: {
     getAttempts: () => attempts,
     getSchema: () => schema,
     getIdentity: () => ({ ...identity }),
+    getFailure: () =>
+      failure === undefined ? undefined : structuredClone(failure),
   };
 }