pi-daddy 0.27.4 → 0.32.0

package/extensions/activity-timeline.ts

@@ -0,0 +1,196 @@
+/** Pi hook wiring for local activity observation. It neither decides grants nor adds child authority. */
+import { createHash, randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import {
+  ActivityTimelineRecorder,
+  ENV_ACTIVITY_TASK,
+  type ActivityIdentity,
+  type ActivitySkill,
+} from "../src/products/activity-timeline.ts";
+
+export interface ActivitySessionState {
+  activityRootId?: string;
+  activity?: ActivityIdentity & { taskId?: string };
+}
+interface HookContext {
+  cwd: string;
+  model?: { id?: string };
+  thinkingLevel?: string;
+  ui: { notify(message: string, level?: "info" | "warning" | "error"): void };
+}
+const digest = (text: string) => createHash("sha256").update(text).digest("hex");
+
+/**
+ * Register observation hooks. `lifecycleTool` is false in a leaf observer injected with `-e`: that
+ * extension has no tools at all, so a child without tool:delegate receives no widened surface.
+ */
+export function registerActivityTimeline(pi: ExtensionAPI, session?: ActivitySessionState, lifecycleTool = true): void {
+  let recorder: ActivityTimelineRecorder | undefined,
+    pendingFinal: string | undefined,
+    finalizedUser: string | undefined;
+  let paths = new Map<string, string>(),
+    available = new Map<string, ActivitySkill>();
+  let reported = false;
+  const report = (ctx: HookContext | undefined, error: unknown) => {
+    if (!reported && ctx) {
+      reported = true;
+      ctx.ui.notify(
+        `pi-daddy activity: observation unavailable (${error instanceof Error ? error.message : String(error)}); governance is unchanged.`,
+        "warning",
+      );
+    }
+  };
+  const current = (ctx: HookContext): ActivityTimelineRecorder => {
+    const env =
+      session?.activityRootId && !process.env.PI_DADDY_ACTIVITY_ROOT
+        ? { ...process.env, PI_DADDY_ACTIVITY_ROOT: session.activityRootId }
+        : process.env;
+    // session_start binds reload ownership after this hook registration; re-create before the first turn
+    // if that binding recovered a prior root identity rather than the factory's provisional UUID.
+    if (
+      !recorder ||
+      (!process.env.PI_DADDY_ACTIVITY_ROOT && session?.activityRootId && recorder.rootId !== session.activityRootId)
+    )
+      recorder = new ActivityTimelineRecorder(ctx.cwd, env);
+    return recorder;
+  };
+  const skills = async (event: unknown, target: ActivityTimelineRecorder) => {
+    available = new Map();
+    const entries =
+      (event as { systemPromptOptions?: { skills?: Array<{ name?: string; filePath?: string }> } }).systemPromptOptions
+        ?.skills ?? [];
+    for (const item of entries) {
+      if (!item.name || !item.filePath) continue;
+      const source = await readFile(item.filePath, "utf8");
+      if (Buffer.byteLength(source) > 256 * 1024) continue;
+      const fact = { name: item.name, source: item.filePath, digest: digest(source) };
+      available.set(resolve(item.filePath), fact);
+      await target.skill("skill_available", fact);
+    }
+  };
+  if (lifecycleTool)
+    pi.registerTool({
+      name: "activity_lifecycle",
+      label: "Activity lifecycle",
+      description:
+        "Declare a runtime skill active, finished, or superseded for the local activity timeline. This is not compliance evidence.",
+      parameters: Type.Object({
+        state: Type.Union([Type.Literal("active"), Type.Literal("finished"), Type.Literal("superseded")]),
+        name: Type.String({ minLength: 1, maxLength: 128 }),
+        source: Type.String({ minLength: 1, maxLength: 1024 }),
+        digest: Type.String({ pattern: "^[a-f0-9]{64}$" }),
+      }),
+      async execute(_id, params) {
+        const kind =
+          params.state === "active"
+            ? "skill_active"
+            : params.state === "finished"
+              ? "skill_finished"
+              : "skill_superseded";
+        await recorder?.skill(kind, { name: params.name, source: params.source, digest: params.digest });
+        return { content: [{ type: "text", text: `Activity recorded: ${params.name} ${params.state}.` }], details: {} };
+      },
+    });
+  pi.on("session_start", (_event, ctx: HookContext) => {
+    try {
+      recorder = current(ctx);
+      // A leaf observer attaches to the parent-owned child event; a root gets a stable session identity.
+      if (process.env[ENV_ACTIVITY_TASK]) recorder.attach(process.env[ENV_ACTIVITY_TASK]!);
+      const identity: ActivityIdentity = {
+        rootId: recorder.rootId,
+        path: recorder.path,
+        ...(recorder.task ? { taskId: recorder.task } : {}),
+      };
+      if (session) session.activity = identity;
+      ctx.ui.notify(
+        recorder.enabled
+          ? `pi-daddy activity: local observation on (${recorder.contentEnabled ? "private prompt/final content" : "metadata only"}); governance is unchanged.`
+          : "pi-daddy activity: observation off; governance is unchanged.",
+        "info",
+      );
+    } catch (error) {
+      report(ctx, error);
+    }
+    return undefined;
+  });
+  pi.on("before_agent_start", async (event, ctx: HookContext) => {
+    try {
+      const target = current(ctx);
+      // An injected leaf observer must not fabricate a second child task; its parent-owned execution seam
+      // already wrote task_started. Root turns always get a fresh task id under their stable root identity.
+      if (!process.env[ENV_ACTIVITY_TASK]) {
+        const taskId = await target.start(
+          finalizedUser ?? (event as { prompt?: string }).prompt ?? "",
+          ctx.model?.id,
+          ctx.thinkingLevel,
+        );
+        finalizedUser = undefined;
+        if (session?.activity)
+          session.activity = { rootId: target.rootId, path: target.path, ...(taskId ? { taskId } : {}) };
+      }
+      await skills(event, target);
+    } catch (error) {
+      report(ctx, error);
+    }
+    return undefined;
+  });
+  pi.on("message_end", (event) => {
+    const message = (
+      event as { message?: { role?: string; content?: string | Array<{ type?: string; text?: string }> } }
+    ).message;
+    const text =
+      typeof message?.content === "string"
+        ? message.content
+        : Array.isArray(message?.content)
+          ? message!.content
+              .filter((part) => part.type === "text")
+              .map((part) => part.text ?? "")
+              .join("")
+          : "";
+    if (message?.role === "user") finalizedUser = text;
+    if (message?.role === "assistant") pendingFinal = text;
+    return undefined;
+  });
+  pi.on("tool_execution_start", (event) => {
+    const value = event as { toolCallId?: string; args?: { path?: unknown } };
+    if (value.toolCallId && typeof value.args?.path === "string") paths.set(value.toolCallId, value.args.path);
+    return undefined;
+  });
+  pi.on("tool_execution_end", async (event) => {
+    try {
+      const value = event as { isError?: boolean; toolName?: string; toolCallId?: string };
+      const path = value.toolCallId ? paths.get(value.toolCallId) : undefined;
+      if (value.toolCallId) paths.delete(value.toolCallId);
+      const skill = path ? available.get(resolve(path)) : undefined;
+      if (!value.isError && value.toolName === "read" && skill) await recorder?.skill("skill_read", skill);
+    } catch {
+      /* observation cannot affect tool execution */
+    }
+    return undefined;
+  });
+  pi.on("agent_settled", async (event, ctx: HookContext) => {
+    try {
+      if (recorder && !process.env[ENV_ACTIVITY_TASK])
+        await recorder.finish(
+          pendingFinal,
+          (event as { cancelled?: boolean; error?: unknown }).cancelled
+            ? "cancelled"
+            : (event as { error?: unknown }).error
+              ? "failed"
+              : "completed",
+        );
+      pendingFinal = undefined;
+    } catch (error) {
+      report(ctx, error);
+    }
+    return undefined;
+  });
+}
+
+/** A no-tool observer used for governed leaves that intentionally do not load grants.ts. */
+export default function activityObserver(pi: ExtensionAPI): void {
+  registerActivityTimeline(pi, undefined, false);
+}

package/extensions/approval-banking.ts

@@ -4,8 +4,8 @@
  * Split out of `./approvals.ts` only to stay under the 400-line module ceiling this project enforces
  * mechanically; `./approvals.ts` re-exports both names.
  */
-import { revokeApproval } from "../src/approval-store.ts";
-import type { Capability } from "../src/resolve.ts";
+import { revokeApproval } from "../src/governance/approval-store.ts";
+import type { Capability } from "../src/kernel/resolve.ts";
 import { snapshotOf } from "./approvals.ts";
 import type { GrantsSession } from "./session.ts";
 
@@ -60,7 +60,7 @@ export async function unbankApprovals(
   if (stranded.length > 0) {
     ctx.ui.notify(
       `grants: this delegation was refused, but a stored approval for ${stranded.join(", ")} could not be ` +
-      `revoked and still stands — remove it with \`/grants revoke\` if it was not intended.`,
+        `revoked and still stands — remove it with \`/grants revoke\` if it was not intended.`,
     );
   }
 }

package/extensions/approvals.ts

@@ -22,18 +22,19 @@ import {
   type InheritableApproval,
   type ResolveApprovalsResult,
   type SubjectSnapshot,
-} from "../src/approval.ts";
-import { loadApprovals, saveApproval } from "../src/approval-store.ts";
-import type { createApprovalGate } from "../src/approval-prompt.ts";
-import { timeoutMsFromEnv, type PromptOutcomeKind } from "../src/approval-prompt.ts";
-import { ceilingForDefinition, digestDefinition } from "../src/definitions.ts";
-import type { Capability } from "../src/resolve.ts";
-import { approvalBindingDigest, type ApprovalBinding } from "../src/correlation.ts";
-import type { RefusalCode } from "../src/refusals.ts";
+} from "../src/kernel/approval.ts";
+import { loadApprovals, saveApproval } from "../src/governance/approval-store.ts";
+import type { createApprovalGate } from "../src/governance/approval-prompt.ts";
+import { timeoutMsFromEnv, type PromptOutcomeKind } from "../src/governance/approval-prompt.ts";
+import { ceilingForDefinition, digestDefinition } from "../src/kernel/definitions.ts";
+import type { Capability } from "../src/kernel/resolve.ts";
+import { approvalBindingDigest, type ApprovalBinding } from "../src/kernel/correlation.ts";
+import type { RefusalCode } from "../src/kernel/refusals.ts";
 import type { GrantsSession } from "./session.ts";
 import type { BankedApproval } from "./approval-banking.ts";
 export { unbankApprovals } from "./approval-banking.ts";
 export type { BankedApproval } from "./approval-banking.ts";
+import { ENV_APPROVAL_TIMEOUT } from "../src/kernel/env-names.ts";
 
 /**
  * What a subject looks like right now, for the confused-deputy check in the approval store.
@@ -234,7 +235,7 @@ export async function obtainApprovals(
     ui: ctx.ui,
     hasUI: ctx.hasUI,
     mode: ctx.mode,
-    timeoutMs: timeoutMsFromEnv(process.env.PI_GRANTS_APPROVAL_TIMEOUT),
+    timeoutMs: timeoutMsFromEnv(process.env[ENV_APPROVAL_TIMEOUT]),
   });
 
   const approved = [...pre.approved];
@@ -254,7 +255,11 @@ export async function obtainApprovals(
 
   for (const capability of pre.needsPrompt) {
     const outcome = await gate.request({
-      capability, subject, path, task, signal,
+      capability,
+      subject,
+      path,
+      task,
+      signal,
       ...(expectedBinding ? { bindingKey: approvalBindingDigest(expectedBinding) } : {}),
     });
     if (outcome.scope === null) {
@@ -292,8 +297,9 @@ export async function obtainApprovals(
       // Whether THIS call created the authority, decided before we add it. `joined` means a human answer
       // opened by another delegation was shared with us; an existing key means it was already standing.
       // Either way it is not ours to take back if we are refused — see `BankedApproval.owned`.
-      const owned = !outcome.joined
-        && !(expectedBinding ? session.sessionApprovalBindings.has(key) : session.sessionApprovals.has(key));
+      const owned =
+        !outcome.joined &&
+        !(expectedBinding ? session.sessionApprovalBindings.has(key) : session.sessionApprovals.has(key));
       if (expectedBinding) session.sessionApprovalBindings.set(key, expectedBinding);
       else session.sessionApprovals.add(key);
       banked.push({ key, capability, subject, persisted: false, owned });

package/extensions/chain-approval-facts.ts

@@ -1,5 +1,5 @@
-import type { InheritableApproval } from "../src/approval.ts";
-import type { Capability } from "../src/resolve.ts";
+import type { InheritableApproval } from "../src/kernel/approval.ts";
+import type { Capability } from "../src/kernel/resolve.ts";
 import type { ApprovalOutcome } from "./approvals.ts";
 
 export interface ChainApprovalAudit {
@@ -36,10 +36,13 @@ export function chainApprovalFacts(
   subject: string,
 ): Pick<ApprovalOutcome, "approved" | "sources" | "scopes" | "expiresAt" | "uses" | "humanDenied"> {
   const entries = available.filter((approval) => approval.subject === subject);
-  const values = <T>(map: Map<string, T>) => Object.fromEntries(entries.flatMap((approval) => {
-    const value = map.get(`${approval.capability}@${approval.subject}`);
-    return value === undefined ? [] : [[approval.capability, value]];
-  }));
+  const values = <T>(map: Map<string, T>) =>
+    Object.fromEntries(
+      entries.flatMap((approval) => {
+        const value = map.get(`${approval.capability}@${approval.subject}`);
+        return value === undefined ? [] : [[approval.capability, value]];
+      }),
+    );
   return {
     approved: entries.map((approval) => approval.capability),
     sources: values(audit.sources),

package/extensions/chain-ledger.ts

@@ -1,8 +1,8 @@
 import type { ApprovalOutcome } from "./approvals.ts";
-import type { Delegation } from "../src/delegate.ts";
-import { appendRecord, buildRecord } from "../src/ledger.ts";
-import type { StructuredRefusal } from "../src/refusals.ts";
-import { childSpawnId } from "../src/fanout.ts";
+import type { Delegation } from "../src/kernel/delegate.ts";
+import { appendRecord, buildRecord } from "../src/governance/ledger.ts";
+import type { StructuredRefusal } from "../src/kernel/refusals.ts";
+import { childSpawnId } from "../src/kernel/fanout.ts";
 import type { GrantsSession } from "./session.ts";
 
 /** Audit a chain preflight/gate refusal with the same trusted planner facts as a normal delegation. */

package/extensions/chain-plan.ts

@@ -1,9 +1,9 @@
-import { DELEGATE_SUBJECT, shouldSeekApproval } from "../src/approval.ts";
-import type { ChainStep } from "../src/chain.ts";
-import { planDelegation } from "../src/delegate.ts";
-import { childSpawnId } from "../src/fanout.ts";
-import type { Capability } from "../src/resolve.ts";
-import type { StructuredRefusal } from "../src/refusals.ts";
+import { DELEGATE_SUBJECT, shouldSeekApproval } from "../src/kernel/approval.ts";
+import type { ChainStep } from "../src/kernel/chain.ts";
+import { planDelegation } from "../src/kernel/delegate.ts";
+import { childSpawnId } from "../src/kernel/fanout.ts";
+import type { Capability } from "../src/kernel/resolve.ts";
+import type { StructuredRefusal } from "../src/kernel/refusals.ts";
 import type { GrantsSession } from "./session.ts";
 
 /** One upfront legacy gate: capability + subject + the exact step whose task the dialog names. */

package/extensions/correlation-shape.ts

@@ -1,39 +1,48 @@
 import { Type } from "typebox";
 
-/** The model-facing form of correlation schema 1.0; runtime validation in src/correlation.ts is the backstop. */
+/** The model-facing form of correlation schema 1.0; runtime validation in src/kernel/correlation.ts is the backstop. */
 export function correlationShape() {
   const assuranceScope = Type.Union([
-    Type.Object({
-      type: Type.Literal("entire-run"),
-      selectors: Type.Array(Type.String({ minLength: 1 }), { maxItems: 0 }),
-    }, { additionalProperties: false }),
-    Type.Object({
-      type: Type.Literal("selectors"),
-      selectors: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
-    }, { additionalProperties: false }),
+    Type.Object(
+      {
+        type: Type.Literal("entire-run"),
+        selectors: Type.Array(Type.String({ minLength: 1 }), { maxItems: 0 }),
+      },
+      { additionalProperties: false },
+    ),
+    Type.Object(
+      {
+        type: Type.Literal("selectors"),
+        selectors: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+      },
+      { additionalProperties: false },
+    ),
   ]);
-  return Type.Object({
-    schema_version: Type.Optional(Type.Literal("1.0")),
-    run_id: Type.Optional(Type.String()),
-    task_id: Type.Optional(Type.String()),
-    workspace_id: Type.Optional(Type.String()),
-    context_id: Type.Optional(Type.String()),
-    phase: Type.Optional(Type.String()),
-    assurance: Type.Optional(Type.String()),
-    assurance_effective: Type.Optional(Type.String()),
-    policy_label: Type.Optional(Type.String()),
-    assurance_source: Type.Optional(Type.String()),
-    assurance_scope: Type.Optional(assuranceScope),
-    activated_at: Type.Optional(Type.String()),
-    plan_digest: Type.Optional(Type.String()),
-    definition_digest: Type.Optional(Type.String()),
-    task_digest: Type.Optional(Type.String()),
-    base_sha: Type.Optional(Type.String()),
-    head_sha: Type.Optional(Type.String()),
-    tree_sha: Type.Optional(Type.String()),
-    event_seq: Type.Optional(Type.Number()),
-    last_change_seq: Type.Optional(Type.Number()),
-    last_authority_seq: Type.Optional(Type.Number()),
-    check_receipt_id: Type.Optional(Type.String()),
-  }, { additionalProperties: false });
+  return Type.Object(
+    {
+      schema_version: Type.Optional(Type.Literal("1.0")),
+      run_id: Type.Optional(Type.String()),
+      task_id: Type.Optional(Type.String()),
+      workspace_id: Type.Optional(Type.String()),
+      context_id: Type.Optional(Type.String()),
+      phase: Type.Optional(Type.String()),
+      assurance: Type.Optional(Type.String()),
+      assurance_effective: Type.Optional(Type.String()),
+      policy_label: Type.Optional(Type.String()),
+      assurance_source: Type.Optional(Type.String()),
+      assurance_scope: Type.Optional(assuranceScope),
+      activated_at: Type.Optional(Type.String()),
+      plan_digest: Type.Optional(Type.String()),
+      definition_digest: Type.Optional(Type.String()),
+      task_digest: Type.Optional(Type.String()),
+      base_sha: Type.Optional(Type.String()),
+      head_sha: Type.Optional(Type.String()),
+      tree_sha: Type.Optional(Type.String()),
+      event_seq: Type.Optional(Type.Number()),
+      last_change_seq: Type.Optional(Type.Number()),
+      last_authority_seq: Type.Optional(Type.Number()),
+      check_receipt_id: Type.Optional(Type.String()),
+    },
+    { additionalProperties: false },
+  );
 }