@happier-dev/stack 0.2.0 → 0.2.11

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityEntryV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentActivityEntryV1.d.ts","sourceRoot":"","sources":["../../src/sessionAgentActivity/agentActivityEntryV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAA+B,KAAK,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAErG;;;;;;;;;GASG;AACH,eAAO,MAAM,sCAAsC,MAAM,CAAC;AAE1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CpC,CAAC;AACX,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,2BAA2B,GAAG,2BAA2B,CAiBzG;AAED;;;;;;;;GAQG;AACH,wBAAgB,uCAAuC,CACrD,KAAK,EAAE,QAAQ,CAAC;IAAE,MAAM,EAAE,qBAAqB,CAAA;CAAE,CAAC,GACjD,MAAM,CAwBR"}

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityEntryV1.js

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+import { AgentActivityKindV1Schema } from './agentActivityKindV1.js';
+import { AgentActivityStatusV1Schema } from './agentActivityStatusV1.js';
+/**
+ * Longest title a headline entry may carry.
+ *
+ * The headline is published into session metadata, which is encrypted, synced and read on every
+ * cold open, so its size is a product cost paid by every client. A row renders one tail-truncated
+ * line, and the untruncated title lives in the durable record the entry points at, so a bound this
+ * generous is invisible in the UI and keeps a full roster in the low kilobytes. The workflow
+ * headline's 4000-character bound is inherited from its snapshot schema and is not a precedent for
+ * a per-entry roster.
+ */
+export const SESSION_AGENT_ACTIVITY_ENTRY_TITLE_MAX = 200;
+/**
+ * One unit of agent work, as the compact headline describes it.
+ *
+ * **A pointer, not a record.** Identity, kind, title, status, timing and the ids needed to find the
+ * real thing — and nothing else. No transcript, no preview, no summary, no payload, no counts
+ * copied off a child. Detail already lives somewhere durable and indexed (a sidechain is queryable
+ * by `sidechainId`; a workflow run has its `activity/workflow_run.v1` record), and a second copy in
+ * session metadata would be a second authority that can disagree with the first.
+ *
+ * Two fields carry hard-won rules:
+ *
+ * - `startedAt` is OPTIONAL and must never be synthesised. Defect D-8 shipped exactly that mistake
+ *   one layer up (`startedAtMs ?? updatedAtMs ?? finishedAtMs ?? 0`), so a finished 16-second run
+ *   reported `0:00`. Absent evidence of a start, the field is absent and the surface shows nothing.
+ * - `updatedAt` is the instant of the most recent EVIDENCE about this entry — not the instant the
+ *   producer last rebuilt it, and specifically not a launch timestamp that never advances. It feeds
+ *   terminal-history ordering here and the quiet/stale presentation downstream, both of which lie
+ *   if it stands still while the work does not.
+ */
+export const SessionAgentActivityEntryV1Schema = z
+    .object({
+    /**
+     * Stable across publishes for the same unit of work, and derived identically by every producer:
+     * the merge that unions this headline with locally derived entries keys on it, so two spellings
+     * of one agent become two rows.
+     */
+    entryId: z.string().trim().min(1),
+    kind: AgentActivityKindV1Schema,
+    title: z.string().trim().min(1).max(SESSION_AGENT_ACTIVITY_ENTRY_TITLE_MAX),
+    status: AgentActivityStatusV1Schema,
+    /** Epoch ms. Absent when no genuine start is known — never back-filled from a finish (D-8). */
+    startedAt: z.number().int().nonnegative().optional(),
+    /** Epoch ms of the most recent evidence about this entry. */
+    updatedAt: z.number().int().nonnegative(),
+    /** The durable sidechain holding this entry's transcript, when it has one. */
+    sidechainId: z.string().trim().min(1).optional(),
+    /** The run this entry belongs to or is, when the kind has one. */
+    runId: z.string().trim().min(1).optional(),
+    /** `entryId` of the owning entry. Authorises grouping and layout only — never numeric rollup. */
+    parentId: z.string().trim().min(1).optional(),
+    /**
+     * Which version of the durable record this entry points at, when its producer versions one.
+     *
+     * The freshness half of "a pointer, not a record". Without it a consumer that hydrates the
+     * durable record has to choose between refetching on every tick and never refetching, and the
+     * one that hydrates `activity/workflow_run.v1` chose the latter — so a run hydrated once and
+     * then froze while it kept looking live. This is what lets it refetch exactly when the record
+     * it already holds became stale, and not otherwise.
+     *
+     * OPTIONAL and additive, in both directions that are reachable: a released producer that
+     * predates the field omits it (the case live today for every non-Claude backend), and a
+     * released reader that predates it strips it. It therefore may never be load-bearing for
+     * existence, status, ordering or bounding — only for cache invalidation.
+     *
+     * OPAQUE: compared for equality, never parsed, ordered or differenced. The workflow producer
+     * happens to write a monotonic decimal string, but that is its private contract with its own
+     * record, not a promise every future kind's record has to keep.
+     */
+    recordRevision: z.string().trim().min(1).optional(),
+})
+    // Strip unknown keys (Zod default, stated): a producer that attaches detail has it dropped on
+    // parse as well as at the projection below. Forward-compatible fields are added explicitly.
+    .strip();
+/**
+ * Narrow an entry to the headline field set.
+ *
+ * The producer-side half of the "headline never holds detail" invariant: structural typing lets a
+ * caller pass a richer object, and this is the chokepoint that stops its extra fields reaching
+ * session metadata regardless. It also clamps the title, so a producer cannot emit an entry that
+ * its own schema would reject and that a reader would then silently drop.
+ */
+export function projectAgentActivityEntry(entry) {
+    const title = entry.title.length > SESSION_AGENT_ACTIVITY_ENTRY_TITLE_MAX
+        ? entry.title.slice(0, SESSION_AGENT_ACTIVITY_ENTRY_TITLE_MAX).trimEnd()
+        : entry.title;
+    const projected = {
+        entryId: entry.entryId,
+        kind: entry.kind,
+        title,
+        status: entry.status,
+        updatedAt: entry.updatedAt,
+    };
+    if (entry.startedAt !== undefined)
+        projected.startedAt = entry.startedAt;
+    if (entry.sidechainId !== undefined)
+        projected.sidechainId = entry.sidechainId;
+    if (entry.runId !== undefined)
+        projected.runId = entry.runId;
+    if (entry.parentId !== undefined)
+        projected.parentId = entry.parentId;
+    if (entry.recordRevision !== undefined)
+        projected.recordRevision = entry.recordRevision;
+    return projected;
+}
+/**
+ * Rank among ACTIVE entries; lower sorts first.
+ *
+ * `waiting` leads because it is the one status a person can clear right now — it is the only status
+ * in the vocabulary that escalates. Then dependency-blocked, then live work, then work that has been
+ * admitted but is not producing yet, then ambiguous. Terminal statuses sort last so that a caller
+ * who hands this comparator a mixed array cannot bury a live entry under finished ones; they never
+ * reach the active list through the builder.
+ */
+export function resolveAgentActivityEntryActivePriority(entry) {
+    switch (entry.status) {
+        case 'waiting':
+            return 0;
+        case 'blocked':
+            return 1;
+        case 'running':
+            return 2;
+        case 'starting':
+            return 3;
+        case 'queued':
+            return 4;
+        case 'unknown':
+            return 5;
+        case 'succeeded':
+        case 'failed':
+        case 'timedOut':
+        case 'cancelled':
+            return 6;
+        default: {
+            const exhaustive = entry.status;
+            return exhaustive;
+        }
+    }
+}
+//# sourceMappingURL=agentActivityEntryV1.js.map

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityEntryV1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentActivityEntryV1.js","sourceRoot":"","sources":["../../src/sessionAgentActivity/agentActivityEntryV1.ts"],"names":[],"mappings":"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"}

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityHeadlineBuild.d.ts

@@ -0,0 +1,41 @@
+import { type SessionAgentActivityEntryV1 } from './agentActivityEntryV1.js';
+import type { SessionAgentActivityHeadlineTruncationV1, SessionAgentActivityHeadlineV1 } from './agentActivityHeadlineV1.js';
+/**
+ * Default terminal-history bound for the compact metadata headline.
+ *
+ * Only `recentEntries` is bounded; `activeEntries` is never capped, for the reason stated in
+ * `../sessionActivityHeadlineOrdering.ts`. The value matches the roster pane's own in-pane finished
+ * cap (24) so the transport is never the thing that starves the surface: a pane that offers to show
+ * 24 finished rows can actually be given 24. Producers may lower it; nothing may cap the active
+ * side. Terminal detail stays durable in the records the entries point at.
+ */
+export declare const SESSION_AGENT_ACTIVITY_RECENT_ENTRIES_LIMIT = 24;
+/** Deterministic active ordering, so every client agrees on the sequence and on `primaryEntryId`. */
+export declare function sortActiveAgentActivityEntries(entries: readonly SessionAgentActivityEntryV1[]): SessionAgentActivityEntryV1[];
+/** Bound only terminal history; never bound live work. */
+export declare function boundRecentAgentActivityEntries(terminalEntries: readonly SessionAgentActivityEntryV1[], limit?: number): {
+    recentEntries: SessionAgentActivityEntryV1[];
+    truncated?: SessionAgentActivityHeadlineTruncationV1;
+};
+/**
+ * `primaryEntryId` is a derived hint, not a second source of truth: `null` when nothing is live,
+ * otherwise the first entry after deterministic active ordering.
+ */
+export declare function resolvePrimaryAgentActivityEntryId(activeEntries: readonly SessionAgentActivityEntryV1[]): string | null;
+export type BuildSessionAgentActivityHeadlineInput = Readonly<{
+    backendId: string;
+    agentId?: string;
+    updatedAt: number;
+    /** Every currently-known entry, live and terminal, in any order. */
+    entries: readonly SessionAgentActivityEntryV1[];
+    recentEntriesLimit?: number;
+}>;
+/**
+ * Build the compact headline from a flat list of entries.
+ *
+ * The single shared builder for this key: the CLI publisher, any test fixture and `../dev` all go
+ * through it, so ordering, bounding and the count-only projection cannot diverge between the
+ * producer and whatever else assembles a headline.
+ */
+export declare function buildSessionAgentActivityHeadline(input: BuildSessionAgentActivityHeadlineInput): SessionAgentActivityHeadlineV1;
+//# sourceMappingURL=agentActivityHeadlineBuild.d.ts.map

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityHeadlineBuild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentActivityHeadlineBuild.d.ts","sourceRoot":"","sources":["../../src/sessionAgentActivity/agentActivityHeadlineBuild.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,2BAA2B,EACjC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,EACV,wCAAwC,EACxC,8BAA8B,EAC/B,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;GAQG;AACH,eAAO,MAAM,2CAA2C,KAAK,CAAC;AAgB9D,qGAAqG;AACrG,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,SAAS,2BAA2B,EAAE,GAC9C,2BAA2B,EAAE,CAE/B;AAED,0DAA0D;AAC1D,wBAAgB,+BAA+B,CAC7C,eAAe,EAAE,SAAS,2BAA2B,EAAE,EACvD,KAAK,GAAE,MAAoD,GAC1D;IAAE,aAAa,EAAE,2BAA2B,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,wCAAwC,CAAA;CAAE,CAUxG;AAED;;;GAGG;AACH,wBAAgB,kCAAkC,CAChD,aAAa,EAAE,SAAS,2BAA2B,EAAE,GACpD,MAAM,GAAG,IAAI,CAEf;AAED,MAAM,MAAM,sCAAsC,GAAG,QAAQ,CAAC;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,OAAO,EAAE,SAAS,2BAA2B,EAAE,CAAC;IAChD,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,sCAAsC,GAC5C,8BAA8B,CAqBhC"}

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityHeadlineBuild.js

@@ -0,0 +1,77 @@
+import { boundRecentActivityHeadlineEntries, partitionActivityHeadlineEntries, sortActiveActivityHeadlineEntries, } from '../sessionActivityHeadlineOrdering.js';
+import { projectAgentActivityEntry, resolveAgentActivityEntryActivePriority, } from './agentActivityEntryV1.js';
+import { isTerminalAgentActivityStatus } from './agentActivityStatusV1.js';
+/**
+ * Default terminal-history bound for the compact metadata headline.
+ *
+ * Only `recentEntries` is bounded; `activeEntries` is never capped, for the reason stated in
+ * `../sessionActivityHeadlineOrdering.ts`. The value matches the roster pane's own in-pane finished
+ * cap (24) so the transport is never the thing that starves the surface: a pane that offers to show
+ * 24 finished rows can actually be given 24. Producers may lower it; nothing may cap the active
+ * side. Terminal detail stays durable in the records the entries point at.
+ */
+export const SESSION_AGENT_ACTIVITY_RECENT_ENTRIES_LIMIT = 24;
+/**
+ * How the shared headline-ordering owner reads an agent-activity entry.
+ *
+ * Terminality, priority and projection are this vocabulary's decisions; ordering, bounding and the
+ * "progress timestamps never touch the active side" rule belong to
+ * `../sessionActivityHeadlineOrdering.ts`, which the workflow headline calls with its own accessors.
+ * One mechanism, two vocabularies — never two comparators.
+ */
+const AGENT_ACTIVITY_ENTRY_ACCESSORS = {
+    id: (entry) => entry.entryId,
+    activePriority: resolveAgentActivityEntryActivePriority,
+    updatedAt: (entry) => entry.updatedAt,
+};
+/** Deterministic active ordering, so every client agrees on the sequence and on `primaryEntryId`. */
+export function sortActiveAgentActivityEntries(entries) {
+    return sortActiveActivityHeadlineEntries(entries, AGENT_ACTIVITY_ENTRY_ACCESSORS);
+}
+/** Bound only terminal history; never bound live work. */
+export function boundRecentAgentActivityEntries(terminalEntries, limit = SESSION_AGENT_ACTIVITY_RECENT_ENTRIES_LIMIT) {
+    const { recent, omittedCount } = boundRecentActivityHeadlineEntries(terminalEntries, AGENT_ACTIVITY_ENTRY_ACCESSORS, limit);
+    if (omittedCount > 0) {
+        return { recentEntries: recent, truncated: { reason: 'entry_limit', omittedCount } };
+    }
+    return { recentEntries: recent };
+}
+/**
+ * `primaryEntryId` is a derived hint, not a second source of truth: `null` when nothing is live,
+ * otherwise the first entry after deterministic active ordering.
+ */
+export function resolvePrimaryAgentActivityEntryId(activeEntries) {
+    return sortActiveAgentActivityEntries(activeEntries)[0]?.entryId ?? null;
+}
+/**
+ * Build the compact headline from a flat list of entries.
+ *
+ * The single shared builder for this key: the CLI publisher, any test fixture and `../dev` all go
+ * through it, so ordering, bounding and the count-only projection cannot diverge between the
+ * producer and whatever else assembles a headline.
+ */
+export function buildSessionAgentActivityHeadline(input) {
+    const { active, recent, omittedCount } = partitionActivityHeadlineEntries({
+        entries: input.entries,
+        accessors: AGENT_ACTIVITY_ENTRY_ACCESSORS,
+        isTerminal: (entry) => isTerminalAgentActivityStatus(entry.status),
+        // Project at the single producer chokepoint so detail can never reach the headline.
+        project: projectAgentActivityEntry,
+        recentLimit: input.recentEntriesLimit ?? SESSION_AGENT_ACTIVITY_RECENT_ENTRIES_LIMIT,
+    });
+    const headline = {
+        v: 1,
+        backendId: input.backendId,
+        updatedAt: input.updatedAt,
+        primaryEntryId: active[0]?.entryId ?? null,
+        activeEntries: active,
+    };
+    if (input.agentId)
+        headline.agentId = input.agentId;
+    if (recent.length > 0)
+        headline.recentEntries = recent;
+    if (omittedCount > 0)
+        headline.truncated = { reason: 'entry_limit', omittedCount };
+    return headline;
+}
+//# sourceMappingURL=agentActivityHeadlineBuild.js.map

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityHeadlineBuild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentActivityHeadlineBuild.js","sourceRoot":"","sources":["../../src/sessionAgentActivity/agentActivityHeadlineBuild.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kCAAkC,EAClC,gCAAgC,EAChC,iCAAiC,GAElC,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,yBAAyB,EACzB,uCAAuC,GAExC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAM3E;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,2CAA2C,GAAG,EAAE,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,8BAA8B,GAAgE;IAClG,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO;IAC5B,cAAc,EAAE,uCAAuC;IACvD,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS;CACtC,CAAC;AAEF,qGAAqG;AACrG,MAAM,UAAU,8BAA8B,CAC5C,OAA+C;IAE/C,OAAO,iCAAiC,CAAC,OAAO,EAAE,8BAA8B,CAAC,CAAC;AACpF,CAAC;AAED,0DAA0D;AAC1D,MAAM,UAAU,+BAA+B,CAC7C,eAAuD,EACvD,KAAK,GAAW,2CAA2C;IAE3D,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,kCAAkC,CACjE,eAAe,EACf,8BAA8B,EAC9B,KAAK,CACN,CAAC;IACF,IAAI,YAAY,GAAG,CAAC,EAAE,CAAC;QACrB,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,EAAE,CAAC;IACvF,CAAC;IACD,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,CAAC;AACnC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kCAAkC,CAChD,aAAqD;IAErD,OAAO,8BAA8B,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,IAAI,CAAC;AAC3E,CAAC;AAWD;;;;;;GAMG;AACH,MAAM,UAAU,iCAAiC,CAC/C,KAA6C;IAE7C,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,gCAAgC,CAAC;QACxE,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,SAAS,EAAE,8BAA8B;QACzC,UAAU,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,6BAA6B,CAAC,KAAK,CAAC,MAAM,CAAC;QAClE,oFAAoF;QACpF,OAAO,EAAE,yBAAyB;QAClC,WAAW,EAAE,KAAK,CAAC,kBAAkB,IAAI,2CAA2C;KACrF,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAmC;QAC/C,CAAC,EAAE,CAAC;QACJ,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,IAAI;QAC1C,aAAa,EAAE,MAAM;KACtB,CAAC;IACF,IAAI,KAAK,CAAC,OAAO;QAAE,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IACpD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;QAAE,QAAQ,CAAC,aAAa,GAAG,MAAM,CAAC;IACvD,IAAI,YAAY,GAAG,CAAC;QAAE,QAAQ,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,CAAC;IACnF,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityHeadlineV1.d.ts

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+/**
+ * The session-metadata key the unified agent-activity headline is published under.
+ *
+ * A CROSS-REPO WIRE LITERAL: remote-dev and `../dev` both write and read this exact string, so it
+ * is protocol-owned rather than restated at each producer and consumer, and it is pinned by a
+ * hand-written literal in `agentActivityHeadlineMetadataKey.test.ts`. It is published ALONGSIDE
+ * `sessionWorkflowActivityHeadlineV1`, which keeps its name, its shape and its own parity lock —
+ * this program is the expand step only (PLAN §5.2); removing the older key is out of scope.
+ */
+export declare const SESSION_AGENT_ACTIVITY_HEADLINE_METADATA_KEY = "sessionAgentActivityHeadlineV1";
+export declare const SessionAgentActivityHeadlineTruncationV1Schema: z.ZodObject<{
+    reason: z.ZodLiteral<"entry_limit">;
+    omittedCount: z.ZodNumber;
+}, z.core.$strip>;
+export type SessionAgentActivityHeadlineTruncationV1 = z.infer<typeof SessionAgentActivityHeadlineTruncationV1Schema>;
+/**
+ * The unified agent-activity headline: a count-only live pointer published into session metadata.
+ *
+ * Shaped deliberately like `SessionWorkflowActivityHeadlineV1` — same envelope, same active/recent
+ * split, same derived-primary hint — because it is DERIVED from that headline rather than parallel
+ * to it (PLAN §3.1), and the two are ported to `../dev` together. What it adds is the ability to
+ * describe kinds of work beyond a workflow run; what it deliberately does not add is detail.
+ *
+ * `activeEntries` is never bounded: a roster that is quietly incomplete is the failure R-3 exists to
+ * prevent. Only `recentEntries` is bounded, and `truncated` says so out loud.
+ */
+export declare const SessionAgentActivityHeadlineV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    backendId: z.ZodString;
+    agentId: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodNumber;
+    primaryEntryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    activeEntries: z.ZodArray<z.ZodObject<{
+        entryId: z.ZodString;
+        kind: z.ZodEnum<{
+            workflow_agent: "workflow_agent";
+            workflow_run: "workflow_run";
+        }>;
+        title: z.ZodString;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            cancelled: "cancelled";
+            failed: "failed";
+            queued: "queued";
+            running: "running";
+            starting: "starting";
+            succeeded: "succeeded";
+            timedOut: "timedOut";
+            unknown: "unknown";
+            waiting: "waiting";
+        }>;
+        startedAt: z.ZodOptional<z.ZodNumber>;
+        updatedAt: z.ZodNumber;
+        sidechainId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        recordRevision: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    recentEntries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        entryId: z.ZodString;
+        kind: z.ZodEnum<{
+            workflow_agent: "workflow_agent";
+            workflow_run: "workflow_run";
+        }>;
+        title: z.ZodString;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            cancelled: "cancelled";
+            failed: "failed";
+            queued: "queued";
+            running: "running";
+            starting: "starting";
+            succeeded: "succeeded";
+            timedOut: "timedOut";
+            unknown: "unknown";
+            waiting: "waiting";
+        }>;
+        startedAt: z.ZodOptional<z.ZodNumber>;
+        updatedAt: z.ZodNumber;
+        sidechainId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        recordRevision: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    truncated: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodLiteral<"entry_limit">;
+        omittedCount: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SessionAgentActivityHeadlineV1 = z.infer<typeof SessionAgentActivityHeadlineV1Schema>;
+/**
+ * Read a headline written by any build of either repo, tolerating entries this build cannot parse.
+ *
+ * The tolerance is the point, and it is not defensive habit: `AgentActivityKindV1` grows a member
+ * every time a kind gains a proven writer (PLAN §5.1 item 11 — `background_task` is already
+ * scheduled), and statuses can follow. With a whole-array parse, the first entry from a newer
+ * producer would take the ENTIRE roster down to `null` on every client that predates it, turning a
+ * forward-compatible addition into a regression for everyone else. Dropping the rows this build
+ * genuinely cannot render, and keeping the ones it can, is the degrade PLAN §5.2 requires.
+ *
+ * Dropped entries are NOT folded into `truncated`: that field means the producer bounded terminal
+ * history, and reusing it for a parse failure would report a producer decision that never happened.
+ *
+ * Returns `null` — never throws — for anything that is not a v1 headline.
+ */
+export declare function parseSessionAgentActivityHeadlineV1(value: unknown): SessionAgentActivityHeadlineV1 | null;
+/**
+ * The one reader of the agent-activity headline out of a session-metadata object.
+ *
+ * Every consumer — CLI, UI, `../dev` — goes through this rather than reaching for the key itself,
+ * so the cross-repo literal has exactly one spelling and the parity lock actually locks something.
+ */
+export declare function readSessionAgentActivityHeadlineFromMetadata(metadata: unknown): SessionAgentActivityHeadlineV1 | null;
+//# sourceMappingURL=agentActivityHeadlineV1.d.ts.map

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityHeadlineV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentActivityHeadlineV1.d.ts","sourceRoot":"","sources":["../../src/sessionAgentActivity/agentActivityHeadlineV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;GAQG;AACH,eAAO,MAAM,4CAA4C,mCAAmC,CAAC;AAE7F,eAAO,MAAM,8CAA8C;;;iBAMjD,CAAC;AACX,MAAM,MAAM,wCAAwC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8CAA8C,CAAC,CAAC;AAEtH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYvC,CAAC;AACX,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAsBlG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,OAAO,GAAG,8BAA8B,GAAG,IAAI,CAiBzG;AAMD;;;;;GAKG;AACH,wBAAgB,4CAA4C,CAC1D,QAAQ,EAAE,OAAO,GAChB,8BAA8B,GAAG,IAAI,CAGvC"}

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityHeadlineV1.js

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import { SessionAgentActivityEntryV1Schema } from './agentActivityEntryV1.js';
+/**
+ * The session-metadata key the unified agent-activity headline is published under.
+ *
+ * A CROSS-REPO WIRE LITERAL: remote-dev and `../dev` both write and read this exact string, so it
+ * is protocol-owned rather than restated at each producer and consumer, and it is pinned by a
+ * hand-written literal in `agentActivityHeadlineMetadataKey.test.ts`. It is published ALONGSIDE
+ * `sessionWorkflowActivityHeadlineV1`, which keeps its name, its shape and its own parity lock —
+ * this program is the expand step only (PLAN §5.2); removing the older key is out of scope.
+ */
+export const SESSION_AGENT_ACTIVITY_HEADLINE_METADATA_KEY = 'sessionAgentActivityHeadlineV1';
+export const SessionAgentActivityHeadlineTruncationV1Schema = z
+    .object({
+    reason: z.literal('entry_limit'),
+    /** Terminal entries the producer's history bound dropped. Never a parse-time drop count. */
+    omittedCount: z.number().int().nonnegative(),
+})
+    .strip();
+/**
+ * The unified agent-activity headline: a count-only live pointer published into session metadata.
+ *
+ * Shaped deliberately like `SessionWorkflowActivityHeadlineV1` — same envelope, same active/recent
+ * split, same derived-primary hint — because it is DERIVED from that headline rather than parallel
+ * to it (PLAN §3.1), and the two are ported to `../dev` together. What it adds is the ability to
+ * describe kinds of work beyond a workflow run; what it deliberately does not add is detail.
+ *
+ * `activeEntries` is never bounded: a roster that is quietly incomplete is the failure R-3 exists to
+ * prevent. Only `recentEntries` is bounded, and `truncated` says so out loud.
+ */
+export const SessionAgentActivityHeadlineV1Schema = z
+    .object({
+    v: z.literal(1),
+    backendId: z.string().trim().min(1),
+    agentId: z.string().trim().min(1).optional(),
+    updatedAt: z.number().int().nonnegative(),
+    /** Derived hint, not a second source of truth: the first active entry, or null when none. */
+    primaryEntryId: z.string().trim().min(1).nullable().optional(),
+    activeEntries: z.array(SessionAgentActivityEntryV1Schema),
+    recentEntries: z.array(SessionAgentActivityEntryV1Schema).optional(),
+    truncated: SessionAgentActivityHeadlineTruncationV1Schema.optional(),
+})
+    .strip();
+/**
+ * The same envelope with unvalidated entries, so the reader below can decide per entry.
+ *
+ * Derived from the canonical schema with `.extend`, not restated, so an envelope field added above
+ * cannot go missing here.
+ */
+const SessionAgentActivityHeadlineEnvelopeV1Schema = SessionAgentActivityHeadlineV1Schema.extend({
+    activeEntries: z.array(z.unknown()),
+    recentEntries: z.array(z.unknown()).optional(),
+});
+function keepReadableEntries(entries) {
+    const readable = [];
+    for (const candidate of entries) {
+        const parsed = SessionAgentActivityEntryV1Schema.safeParse(candidate);
+        if (parsed.success)
+            readable.push(parsed.data);
+    }
+    return readable;
+}
+/**
+ * Read a headline written by any build of either repo, tolerating entries this build cannot parse.
+ *
+ * The tolerance is the point, and it is not defensive habit: `AgentActivityKindV1` grows a member
+ * every time a kind gains a proven writer (PLAN §5.1 item 11 — `background_task` is already
+ * scheduled), and statuses can follow. With a whole-array parse, the first entry from a newer
+ * producer would take the ENTIRE roster down to `null` on every client that predates it, turning a
+ * forward-compatible addition into a regression for everyone else. Dropping the rows this build
+ * genuinely cannot render, and keeping the ones it can, is the degrade PLAN §5.2 requires.
+ *
+ * Dropped entries are NOT folded into `truncated`: that field means the producer bounded terminal
+ * history, and reusing it for a parse failure would report a producer decision that never happened.
+ *
+ * Returns `null` — never throws — for anything that is not a v1 headline.
+ */
+export function parseSessionAgentActivityHeadlineV1(value) {
+    const envelope = SessionAgentActivityHeadlineEnvelopeV1Schema.safeParse(value);
+    if (!envelope.success)
+        return null;
+    const headline = {
+        v: 1,
+        backendId: envelope.data.backendId,
+        updatedAt: envelope.data.updatedAt,
+        activeEntries: keepReadableEntries(envelope.data.activeEntries),
+    };
+    if (envelope.data.agentId !== undefined)
+        headline.agentId = envelope.data.agentId;
+    if (envelope.data.primaryEntryId !== undefined)
+        headline.primaryEntryId = envelope.data.primaryEntryId;
+    if (envelope.data.recentEntries !== undefined) {
+        headline.recentEntries = keepReadableEntries(envelope.data.recentEntries);
+    }
+    if (envelope.data.truncated !== undefined)
+        headline.truncated = envelope.data.truncated;
+    return headline;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * The one reader of the agent-activity headline out of a session-metadata object.
+ *
+ * Every consumer — CLI, UI, `../dev` — goes through this rather than reaching for the key itself,
+ * so the cross-repo literal has exactly one spelling and the parity lock actually locks something.
+ */
+export function readSessionAgentActivityHeadlineFromMetadata(metadata) {
+    if (!isRecord(metadata))
+        return null;
+    return parseSessionAgentActivityHeadlineV1(metadata[SESSION_AGENT_ACTIVITY_HEADLINE_METADATA_KEY]);
+}
+//# sourceMappingURL=agentActivityHeadlineV1.js.map

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityHeadlineV1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentActivityHeadlineV1.js","sourceRoot":"","sources":["../../src/sessionAgentActivity/agentActivityHeadlineV1.ts"],"names":[],"mappings":"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"}

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityKindV1.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/**
+ * What kind of work an agent-activity entry describes.
+ *
+ * MEMBERSHIP IS DECIDED BY PRODUCERS, NOT BY DESIGN INTENT. A kind is added here only in the same
+ * change that lands its live writer, with evidence that the writer actually publishes in a real
+ * session. A kind with no writer is a dormant horizontal spine: consumers branch on a value that
+ * can never arrive, and the branch rots.
+ *
+ * v1 ships the two kinds carried by the one activity record that is published today —
+ * `activity/workflow_run.v1`, written by `apps/cli/src/session/systemRecords/activity/**`, whose
+ * snapshot holds both the run and its agents.
+ *
+ * Waiting on their producers:
+ * - `subagent`, `execution_run` — added once their observation source is evidenced.
+ * - `agent_team_member` — added only if a writer is proven to exist.
+ * - `background_task` — added together with its CLI producer.
+ * - `scheduled_run` — never: automations are account-scoped and terminal at dispatch, so they are
+ *   excluded from agent activity outright.
+ * - `monitor` / `monitor_mcp` — classification buckets only; no member without a verified producer.
+ *
+ * Adding a member is a one-line change to the tuple below. Consumers must therefore treat this as
+ * an open vocabulary: switch on it only where a total mapping is genuinely required, and use a
+ * `never` check there so the compiler points at every site the new kind reaches.
+ */
+export declare const AGENT_ACTIVITY_KINDS_V1: readonly ['workflow_run', 'workflow_agent'];
+export declare const AgentActivityKindV1Schema: z.ZodEnum<{
+    workflow_agent: "workflow_agent";
+    workflow_run: "workflow_run";
+}>;
+export type AgentActivityKindV1 = z.infer<typeof AgentActivityKindV1Schema>;
+//# sourceMappingURL=agentActivityKindV1.d.ts.map

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityKindV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentActivityKindV1.d.ts","sourceRoot":"","sources":["../../src/sessionAgentActivity/agentActivityKindV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,uBAAuB,YAClC,cAAc,EACd,gBAAgB,CACR,CAAC;AAEX,eAAO,MAAM,yBAAyB;;;EAAkC,CAAC;AACzE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityKindV1.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+/**
+ * What kind of work an agent-activity entry describes.
+ *
+ * MEMBERSHIP IS DECIDED BY PRODUCERS, NOT BY DESIGN INTENT. A kind is added here only in the same
+ * change that lands its live writer, with evidence that the writer actually publishes in a real
+ * session. A kind with no writer is a dormant horizontal spine: consumers branch on a value that
+ * can never arrive, and the branch rots.
+ *
+ * v1 ships the two kinds carried by the one activity record that is published today —
+ * `activity/workflow_run.v1`, written by `apps/cli/src/session/systemRecords/activity/**`, whose
+ * snapshot holds both the run and its agents.
+ *
+ * Waiting on their producers:
+ * - `subagent`, `execution_run` — added once their observation source is evidenced.
+ * - `agent_team_member` — added only if a writer is proven to exist.
+ * - `background_task` — added together with its CLI producer.
+ * - `scheduled_run` — never: automations are account-scoped and terminal at dispatch, so they are
+ *   excluded from agent activity outright.
+ * - `monitor` / `monitor_mcp` — classification buckets only; no member without a verified producer.
+ *
+ * Adding a member is a one-line change to the tuple below. Consumers must therefore treat this as
+ * an open vocabulary: switch on it only where a total mapping is genuinely required, and use a
+ * `never` check there so the compiler points at every site the new kind reaches.
+ */
+export const AGENT_ACTIVITY_KINDS_V1 = [
+    'workflow_run',
+    'workflow_agent',
+];
+export const AgentActivityKindV1Schema = z.enum(AGENT_ACTIVITY_KINDS_V1);
+//# sourceMappingURL=agentActivityKindV1.js.map

package/node_modules/@happier-dev/protocol/dist/sessionAgentActivity/agentActivityKindV1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentActivityKindV1.js","sourceRoot":"","sources":["../../src/sessionAgentActivity/agentActivityKindV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,cAAc;IACd,gBAAgB;CACR,CAAC;AAEX,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC"}