@indigoai-us/hq-cli 5.345.198 → 5.345.199

package/dist/lib/plan-limit-nag.js

@@ -63,6 +63,52 @@ export const PLAN_LIMIT_DIMENSION_LABELS = {
     deployments: "deployments",
     storageBytes: "storage",
 };
+/**
+ * Bytes in one GB as plan limits count them: 2^30. hq-pro stores the "10 GB"
+ * and "2 GB" storage ceilings as GiB and its limit emails print them as
+ * "10 GB" / "2 GB"; `lib/billing/usage-cost.ts` uses the same unit
+ * (BYTES_PER_GB). Kept local so this hot-path module loads no billing code.
+ */
+const STORAGE_BYTES_PER_GB = 1024 ** 3;
+/**
+ * Render one amount of a resource. Storage arrives in bytes; printed raw it
+ * reads as "47012700666 of 10737418240". It is shown in GB with one decimal,
+ * so a 10 GB ceiling reads "10.0 GB", matching the plan's own wording.
+ */
+export function formatPlanLimitAmount(key, n) {
+    if (key !== "storageBytes")
+        return String(n);
+    return `${(n / STORAGE_BYTES_PER_GB).toFixed(1)} GB`;
+}
+/**
+ * The account as a noun phrase: "your personal account", "the acme company",
+ * or "this account" when an older hq-pro sent no label.
+ */
+export function planLimitAccountPhrase(account) {
+    if (account?.kind === "person")
+        return "your personal account";
+    if (account?.kind === "company" && account.slug)
+        return `the ${account.slug} company`;
+    return "this account";
+}
+function parseAccount(body) {
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        return null;
+    }
+    const raw = body.account;
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const rec = raw;
+    if (rec.kind === "person")
+        return { kind: "person" };
+    if (rec.kind === "company") {
+        const slug = typeof rec.slug === "string" && rec.slug.trim().length > 0
+            ? rec.slug.trim()
+            : null;
+        return { kind: "company", slug };
+    }
+    return null;
+}
 function dimensionSuffix(key) {
     const label = PLAN_LIMIT_DIMENSION_LABELS[key];
     return label && label !== key ? ` (${label})` : "";
@@ -252,14 +298,15 @@ export function recordPlanLimitStatus(body, opts = {}) {
                 legacyUrl: status?.upgradeUrl ?? PLAN_LIMIT_UPGRADE_URL,
             });
         }
+        const account = parseAccount(body);
         if (status !== null) {
             const anyOver = Object.values(status.limits).some((e) => e.over);
-            lastSeen = { ...status, anyOver, upgradeUrl: resolvedUpgradeUrl };
+            lastSeen = { ...status, anyOver, upgradeUrl: resolvedUpgradeUrl, account };
         }
         // Independent of `planLimits`: the server can announce a crossing on a
         // response whose nag map this CLI could not parse, and the notice is the
         // one surface that must land inside a session that is already running.
-        emitPlanLimitThresholdNotice(crossings, resolvedUpgradeUrl, opts);
+        emitPlanLimitThresholdNotice(crossings, resolvedUpgradeUrl, { ...opts, account });
     }
     catch {
         // Never throw from record path.
@@ -287,7 +334,7 @@ function formatPct(entry) {
     return `${Math.round((entry.used / entry.limit) * 100)}%`;
 }
 function formatEntryLine(key, entry) {
-    return `${key} at ${entry.used}/${entry.limit} (${formatPct(entry)})${dimensionSuffix(key)}`;
+    return `${key} at ${formatPlanLimitAmount(key, entry.used)}/${formatPlanLimitAmount(key, entry.limit)} (${formatPct(entry)})${dimensionSuffix(key)}`;
 }
 /**
  * Read the whole state file. A missing, unreadable or malformed file is an
@@ -360,16 +407,18 @@ function withinNagWindow(shownAt, nowMs) {
 /**
  * The over-limit per-turn line (US-036 §2.2). One line, not the old box: it
  * now repeats up to four times a day, and a multi-line box at that cadence
- * reads as breakage rather than as a nag. It states the two paused things and
- * never claims the workspace has stopped working.
+ * reads as breakage rather than as a nag. It names the account and states the
+ * facts. It claims no pause: being over is not being refused. A refusal comes
+ * back from hq-pro as its own error with its own sentence, and that is the
+ * only place a pause is reported (feedback_b1867fe6, where this line told a
+ * person their uploads were paused right after two uploads succeeded).
  */
-export function buildOverLine(overEntries, upgradeUrl) {
+export function buildOverLine(overEntries, upgradeUrl, account = null) {
     const facts = overEntries
-        .map(([key, entry]) => `${PLAN_LIMIT_DIMENSION_LABELS[key] ?? key} ${entry.used} of ${entry.limit}`)
+        .map(([key, entry]) => `${PLAN_LIMIT_DIMENSION_LABELS[key] ?? key} ${formatPlanLimitAmount(key, entry.used)} of ${formatPlanLimitAmount(key, entry.limit)}`)
         .join(", ");
     // US-024: names no plan and offers no upgrade; the link is the Billing page.
-    return (`⚠ Over this account's limits: ${facts}. New files and new secrets are paused. ` +
-        `Billing: ${upgradeUrl}`);
+    return `⚠ Over ${planLimitAccountPhrase(account)}'s limits: ${facts}. Billing: ${upgradeUrl}`;
 }
 // ---------------------------------------------------------------------------
 // Personal feature notice (US-054, copy per US-024)
@@ -424,12 +473,14 @@ function dimensionName(resource) {
  * their own story, and a notice that announces a pause nobody is experiencing
  * reads as a bug.
  */
-export function renderThresholdNotice(crossing, upgradeUrl) {
+export function renderThresholdNotice(crossing, upgradeUrl, account = null) {
     const name = dimensionName(crossing.resource);
-    const counts = `${crossing.used} of ${crossing.limit}`;
+    const counts = `${formatPlanLimitAmount(crossing.resource, crossing.used)} of ${formatPlanLimitAmount(crossing.resource, crossing.limit)}`;
+    // An unlabelled payload (older hq-pro) keeps the original wording.
+    const where = account ? ` for ${planLimitAccountPhrase(account)}` : "";
     const headline = crossing.band === "over"
-        ? `You are past your ${name} limit (${counts}).`
-        : `You have reached 80% of your ${name} limit (${counts}).`;
+        ? `You are past your ${name} limit${where} (${counts}).`
+        : `You have reached 80% of your ${name} limit${where} (${counts}).`;
     return `${headline} Billing: ${upgradeUrl}`;
 }
 /**
@@ -461,7 +512,7 @@ export function emitPlanLimitThresholdNotice(crossings, upgradeUrl, opts = {}) {
                 continue;
             thresholdsShownThisSession.set(key, crossing.firstSeenAt);
             printed[key] = crossing.firstSeenAt;
-            write(chalk.yellow(renderThresholdNotice(crossing, resolvedUpgradeUrl)) + "\n");
+            write(chalk.yellow(renderThresholdNotice(crossing, resolvedUpgradeUrl, opts.account ?? null)) + "\n");
             if (isCliLimitResourceKind(crossing.resource)) {
                 queueCliLimitNoticeExposure(crossing.resource, "advisory");
             }
@@ -489,7 +540,7 @@ export function emitPlanLimitNag(opts = {}) {
         const write = opts.write ?? ((s) => process.stderr.write(s));
         const now = opts.now ?? (() => new Date());
         const statePath = opts.statePath ?? defaultStatePath();
-        const { limits, anyOver, upgradeUrl } = lastSeen;
+        const { limits, anyOver, upgradeUrl, account } = lastSeen;
         const resolvedUpgradeUrl = upgradeUrl ??
             planLimitUpgradeFallbackUrl(resolveProcessFlagCompanyContext().companySlug, PLAN_LIMIT_UPGRADE_URL);
         const entries = Object.entries(limits);
@@ -504,7 +555,7 @@ export function emitPlanLimitNag(opts = {}) {
                 return;
             overShownThisSession = true;
             const overEntries = entries.filter(([, e]) => e.over);
-            const line = buildOverLine(overEntries, resolvedUpgradeUrl);
+            const line = buildOverLine(overEntries, resolvedUpgradeUrl, account);
             write(chalk.yellow(line) + "\n");
             const resourceKind = overEntries[0]?.[0];
             if (resourceKind && isCliLimitResourceKind(resourceKind)) {
@@ -520,7 +571,7 @@ export function emitPlanLimitNag(opts = {}) {
         if (worst === null)
             return;
         warningShownThisSession = true;
-        const line = `⚠ Nearing this account's limits: ${formatEntryLine(worst.key, worst.entry)}. Make room before you hit the cap. Billing: ${resolvedUpgradeUrl}`;
+        const line = `⚠ Nearing ${planLimitAccountPhrase(account)}'s limits: ${formatEntryLine(worst.key, worst.entry)}. Make room before you hit the cap. Billing: ${resolvedUpgradeUrl}`;
         write(chalk.yellow(line) + "\n");
         if (isCliLimitResourceKind(worst.key)) {
             queueCliLimitNoticeExposure(worst.key, "advisory");

package/dist/lib/signals/engine.d.ts

@@ -1,3 +1,4 @@
+import { type IncrementalOptions } from "./incremental.js";
 import { localDate } from "./local-date.js";
 import { type LockTakeover } from "./run-lock.js";
 import { type UploadDeps } from "./steps/upload.js";
@@ -130,6 +131,9 @@ export interface RunSignalsResult {
     alerts?: Record<string, RaiseSignalsFailureAlertsResult>;
 }
 export interface RunSignalsOptions {
+    source?: string;
+    incremental?: boolean;
+    incrementalOptions?: IncrementalOptions;
     hqRoot: string;
     company?: string;
     dryRun?: boolean;

package/dist/lib/signals/engine.js

@@ -12,7 +12,8 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import yaml from "js-yaml";
-import { loadSignalsSettings } from "./settings.js";
+import { loadSignalsSettings, loadIncrementalSettings } from "./settings.js";
+import { createIncrementalStep } from "./incremental.js";
 import { localDate } from "./local-date.js";
 import { guardedWrite, WriteGuardError } from "./write-guard.js";
 import { acquireCompanyLock, withSummaryLock } from "./run-lock.js";
@@ -46,6 +47,7 @@ export const defaultSpawn = (cmd, args, opts) => {
         cwd: opts.cwd,
         env: opts.env ?? process.env,
         encoding: "utf8",
+        input: opts.input,
         maxBuffer: 64 * 1024 * 1024,
         ...(opts.timeoutMs !== undefined ? { timeout: opts.timeoutMs, killSignal: "SIGKILL" } : {}),
     });
@@ -246,9 +248,22 @@ export async function runSignals(opts) {
     const stepChoice = opts.step ?? "all";
     const dryRun = opts.dryRun === true;
     const settings = loadSignalsSettings(hqRoot);
-    const maxTurns = opts.maxTurns ?? settings.maxTurns;
-    const maxBudgetUsd = opts.maxBudgetUsd ?? settings.maxBudgetUsd;
+    if (opts.source !== undefined || opts.incremental) {
+        if (!opts.source || !opts.incremental || !opts.company)
+            throw new SignalsUsageError("--source and --incremental require each other and --company");
+        if ((opts.step && opts.step !== "all" && opts.step !== "extract") || opts.redo?.length)
+            throw new SignalsUsageError("--incremental cannot be combined with --redo or another step");
+        if (!/^[a-zA-Z0-9_-]+:[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(opts.source))
+            throw new SignalsUsageError("invalid --source: expected <channel>:<file>");
+    }
+    const limits = opts.incremental ? loadIncrementalSettings(hqRoot) : settings;
+    const maxTurns = opts.maxTurns ?? limits.maxTurns;
+    const maxBudgetUsd = opts.maxBudgetUsd ?? limits.maxBudgetUsd;
+    if (!Number.isInteger(maxTurns) || maxTurns < 1 || !Number.isFinite(maxBudgetUsd) || maxBudgetUsd < 0)
+        throw new SignalsUsageError("invalid model cost limits");
     const stepImpls = { ...DEFAULT_STEPS, ...(opts.steps ?? {}) };
+    if (opts.incremental)
+        stepImpls.extract = createIncrementalStep(opts.source, opts.incrementalOptions);
     if (opts.company !== undefined && !SLUG_RE.test(opts.company)) {
         throw new SignalsUsageError(`invalid company slug: ${opts.company}`);
     }
@@ -266,12 +281,14 @@ export async function runSignals(opts) {
     const companies = opts.company !== undefined ? [opts.company] : listCompanies(hqRoot);
     const start = now();
     const date = localDate(start);
-    const lateStart = trigger === "job" && start.getHours() >= settings.lateStartHour;
+    const lateStart = !opts.incremental && trigger === "job" && start.getHours() >= settings.lateStartHour;
     let plan = stepChoice === "all" ? STEP_ORDER : STEP_ORDER.filter((s) => s === stepChoice);
     if (stepChoice !== "all")
         plan = plan.slice(0, 1);
     if (lateStart)
         plan = plan.filter((s) => s === "garden").slice(0, 1);
+    if (opts.incremental)
+        plan = ["extract"];
     const records = [];
     const locked = [];
     for (const company of companies) {
@@ -324,7 +341,10 @@ export async function runSignals(opts) {
         };
         const finish = () => {
             const decidedSkip = record.skipReason;
+            const previousJobRanAt = record.jobRanAt;
             finalizeRecord(record, { lateStart, lateStartHour: settings.lateStartHour, finishedAt: now() });
+            if (opts.incremental)
+                record.jobRanAt = previousJobRanAt;
             if (dryRun) {
                 if (!decidedSkip) {
                     record.status = "dry-run";
@@ -343,7 +363,7 @@ export async function runSignals(opts) {
             // 2. The day's job already ran: do nothing and leave the record as it is.
             const prior = readJson(hqRoot, rel);
             const priorJobRanAt = typeof prior?.jobRanAt === "string" ? prior.jobRanAt : null;
-            if (trigger === "job" && !opts.force && prior && priorJobRanAt) {
+            if (!opts.incremental && trigger === "job" && !opts.force && prior && priorJobRanAt) {
                 process.stderr.write(`hq signals: ${company}: already-ran (the job ran at ${priorJobRanAt})\n`);
                 records.push({ ...prior, alreadyRanToday: true });
                 continue;

package/dist/lib/signals/incremental.d.ts

@@ -0,0 +1,42 @@
+import { type PriorSignal } from "./steps/extract.js";
+import type { SignalsStep, StepContext } from "./steps/types.js";
+export { meetingSignalSourceRef } from "../hot-channels/meeting-source-ref.js";
+export interface IncrementalCursor {
+    revision: number;
+    segment_count: number;
+    last_run_at: string;
+    signal_ids: string[];
+    digest: string;
+    pending_events?: SignalWritten[];
+}
+export interface SourceSnapshot {
+    sourceRef: string;
+    text: string;
+    segmentCount: number;
+    revision?: number;
+    audience: string[];
+}
+export type SourceReader = (ctx: StepContext, id: string) => Promise<SourceSnapshot>;
+export type SignalWritten = {
+    event: "signal.written";
+    signal_id: string;
+    type: string;
+    source_ref: string;
+    company: string;
+    key: string;
+};
+export interface IncrementalOptions {
+    readers?: Readonly<Record<string, SourceReader>>;
+    /** US-004/005 integration seam: one callback per newly persisted signal. */
+    onSignalWritten?: (event: SignalWritten) => Promise<void>;
+}
+export declare const SOURCE_READERS: Readonly<Record<string, SourceReader>>;
+export declare function readIncrementalSource(ctx: StepContext, ref: string, readers?: Readonly<Record<string, SourceReader>>): Promise<SourceSnapshot>;
+export declare function cursorPath(company: string, sourceRef: string): string;
+/** Only read the current audience partition, never another audience's signals. */
+export declare function priorSignalsFor(ctx: StepContext, sourceRef: string, audience: string[]): Array<PriorSignal & {
+    key: string;
+    live: boolean;
+}>;
+export declare function createIncrementalStep(source: string, options?: IncrementalOptions): SignalsStep;
+//# sourceMappingURL=incremental.d.ts.map

package/dist/lib/signals/incremental.js

@@ -0,0 +1,191 @@
+/** Incremental source readers and cursor transaction, executed under the engine's company lock. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createHash } from "node:crypto";
+import yaml from "js-yaml";
+import { ensureCognitoToken } from "../../utils/cognito-session.js";
+import { getCompanyUid, resolveCallerPersonUid, vaultApiFetch } from "../../utils/vault-api.js";
+import { audienceKey } from "../hot-channels/audience.js";
+import { assertSafeSegment } from "../hot-channels/landing.js";
+import { appendSignalIndex, signalId, signalTypeDir, splitFrontmatter } from "../hot-channels/signals-pass.js";
+import { acquireSyncLock } from "../hot-channels/sync-lock.js";
+import { assertAllowedPath } from "./write-guard.js";
+import { createExtractStep } from "./steps/extract.js";
+import { meetingSignalSourceRef } from "../hot-channels/meeting-source-ref.js";
+export { meetingSignalSourceRef } from "../hot-channels/meeting-source-ref.js";
+/** Stable across partial revisions and the adapter's landed transcript. */
+const meetingReader = async (ctx, id) => {
+    const sourceRef = meetingSignalSourceRef(id);
+    const token = await ensureCognitoToken();
+    const companyId = await getCompanyUid(token, ctx.company);
+    const response = await vaultApiFetch({ token, path: `/v1/meetings/${encodeURIComponent(id)}`, query: { companyId, view: "live" } });
+    if (!response.ok)
+        throw new Error("Could not read this live meeting. Check meeting access and retry.");
+    const data = await response.json();
+    if (!Number.isInteger(data.revision) || !Array.isArray(data.segments) || data.full === false)
+        throw new Error("Invalid full live transcript snapshot");
+    const lines = data.segments.map((s) => {
+        if (!s || typeof s !== "object" || typeof s.text !== "string")
+            throw new Error("Invalid live transcript segment");
+        const segment = s;
+        return `[${typeof segment.startSeconds === "number" ? segment.startSeconds : 0}] ${typeof segment.speaker === "string" ? segment.speaker : "Speaker"}: ${segment.text}`;
+    });
+    // Never broaden live meeting content to the company. The authenticated reader
+    // has access; a final transcript supplies the authoritative attendee audience.
+    const person = await resolveCallerPersonUid(token);
+    return { sourceRef, text: lines.join("\n"), segmentCount: lines.length, revision: data.revision, audience: [person] };
+};
+export const SOURCE_READERS = { meeting: meetingReader };
+export async function readIncrementalSource(ctx, ref, readers = SOURCE_READERS) {
+    const colon = ref.indexOf(":");
+    if (colon < 1)
+        throw new Error("--source must be <channel>:<file> or meeting:<id>");
+    const channel = ref.slice(0, colon);
+    const id = ref.slice(colon + 1);
+    assertSafeSegment(channel, "source channel");
+    assertSafeSegment(id, "source id");
+    const reader = Object.hasOwn(readers, channel) ? readers[channel] : undefined;
+    if (reader)
+        return reader(ctx, id);
+    const name = id.endsWith(".md") ? id : `${id}.md`;
+    const key = `sources/${channel}/${name}`;
+    const file = assertAllowedPath(ctx.hqRoot, `companies/${ctx.company}/${key}`, { company: ctx.company });
+    const text = fs.readFileSync(file, "utf8");
+    const { frontmatter } = splitFrontmatter(text);
+    const audience = Array.isArray(frontmatter.audience) ? frontmatter.audience.filter((p) => typeof p === "string" && p.trim().length > 0) : [];
+    if (audience.length === 0)
+        throw new Error("Source has no audience; add its intended audience before extracting signals");
+    const sourceRef = typeof frontmatter.signal_source_ref === "string" && /^meeting:[a-zA-Z0-9._-]+$/.test(frontmatter.signal_source_ref) ? frontmatter.signal_source_ref : key;
+    return { sourceRef, text, segmentCount: text.split(/\r?\n/).filter(Boolean).length, audience };
+}
+export function cursorPath(company, sourceRef) {
+    assertSafeSegment(company, "company");
+    const safe = createHash("sha256").update(sourceRef).digest("hex");
+    return `workspace/executive/signals/${company}/${safe}.cursor.json`;
+}
+function readCursor(ctx, sourceRef) {
+    const file = assertAllowedPath(ctx.hqRoot, cursorPath(ctx.company, sourceRef), { company: ctx.company });
+    if (!fs.existsSync(file))
+        return null;
+    const c = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (!Number.isInteger(c.revision) || c.revision < 0 || !Number.isInteger(c.segment_count) || c.segment_count < 0 ||
+        typeof c.digest !== "string" || !Array.isArray(c.signal_ids) || !c.signal_ids.every((id) => /^[a-f0-9]{64}$/.test(id)))
+        throw new Error("Invalid incremental cursor; restore it before retrying");
+    if (c.pending_events !== undefined && (!Array.isArray(c.pending_events) || c.pending_events.some((e) => !e || e.event !== "signal.written" || e.company !== ctx.company || e.source_ref !== sourceRef || !c.signal_ids.includes(e.signal_id) || typeof e.type !== "string" || typeof e.key !== "string")))
+        throw new Error("Invalid incremental event cursor");
+    return c;
+}
+/** Only read the current audience partition, never another audience's signals. */
+export function priorSignalsFor(ctx, sourceRef, audience) {
+    const partition = audienceKey(audience);
+    const out = [];
+    for (const type of ["action_item", "commitment", "decision", "risk", "question", "key_point", "participant_contribution", "summary"]) {
+        const dir = signalTypeDir(partition, type);
+        const root = assertAllowedPath(ctx.hqRoot, `companies/${ctx.company}/${dir}/probe.md`, { company: ctx.company });
+        if (!fs.existsSync(path.dirname(root)))
+            continue;
+        for (const name of fs.readdirSync(path.dirname(root))) {
+            if (!/^[a-f0-9]{64}\.md$/.test(name))
+                continue;
+            const key = `${dir}/${name}`;
+            const file = assertAllowedPath(ctx.hqRoot, `companies/${ctx.company}/${key}`, { company: ctx.company });
+            const { frontmatter: fm } = splitFrontmatter(fs.readFileSync(file, "utf8"));
+            if (fm.source_ref !== sourceRef || fm.signal_id !== name.slice(0, -3) || fm.type !== type || typeof fm.canonical_content !== "string")
+                continue;
+            out.push({ signal_id: fm.signal_id, type, title: fm.canonical_content, key, live: fm.origin === "live" });
+        }
+    }
+    return out;
+}
+export function createIncrementalStep(source, options = {}) {
+    return {
+        name: "extract",
+        async run(ctx) {
+            const readers = { ...SOURCE_READERS, ...options.readers };
+            let snapshot = await readIncrementalSource(ctx, source, readers);
+            const vaultRoot = path.join(ctx.hqRoot, "companies", ctx.company);
+            const lock = await acquireSyncLock(vaultRoot, `incremental-${createHash("sha256").update(snapshot.sourceRef).digest("hex")}`);
+            if (!lock)
+                throw new Error("Another incremental run holds this source; retry later");
+            try {
+                // Resolve the lock identity first, then read content while holding it.
+                // A slow initial read must not overwrite a newer run's snapshot.
+                const lockedSnapshot = await readIncrementalSource(ctx, source, readers);
+                if (lockedSnapshot.sourceRef !== snapshot.sourceRef)
+                    throw new Error("Source identity changed while acquiring its lock; retry later");
+                snapshot = lockedSnapshot;
+                const digest = createHash("sha256").update(snapshot.text).update(JSON.stringify(snapshot.audience)).digest("hex");
+                const cursor = readCursor(ctx, snapshot.sourceRef);
+                // Events are persisted with the cursor before delivery. A failed callback
+                // is retried on the next pass without asking the model to recreate a file.
+                const deliver = async (state) => {
+                    while (options.onSignalWritten && state.pending_events?.length) {
+                        await options.onSignalWritten(state.pending_events[0]);
+                        await lock.assertHeld();
+                        state.pending_events.shift();
+                        ctx.write(cursorPath(ctx.company, snapshot.sourceRef), `${JSON.stringify(state, null, 2)}\n`);
+                    }
+                };
+                if (cursor)
+                    await deliver(cursor);
+                const empty = { status: "ok", itemsIn: 0, itemsOut: 0, modelTurns: 0, estimatedSpendUsd: 0, detail: { new_segments: 0, signals_written: 0 } };
+                if (cursor?.digest === digest || (!cursor && !snapshot.text.trim()))
+                    return empty;
+                const revision = (cursor?.revision ?? 0) + 1;
+                const prior = priorSignalsFor(ctx, snapshot.sourceRef, snapshot.audience);
+                const result = await createExtractStep({ documentOverride: { ...snapshot, partial: true, revision }, priorSignals: prior.map(({ signal_id, type, title }) => ({ signal_id, type, title })) }).run(ctx);
+                if (result.status !== "ok")
+                    return result;
+                const signals = result.detail?.signals;
+                for (const signal of signals) {
+                    if (signal.update && !prior.some((p) => p.signal_id === signal.update && p.type === signal.type))
+                        throw new Error("Update id is not a prior signal of this source and type");
+                }
+                await lock.assertHeld();
+                const partition = audienceKey(snapshot.audience);
+                const at = ctx.now().toISOString();
+                const added = [];
+                const ids = new Set(cursor?.signal_ids ?? []);
+                if (partition !== "company")
+                    ctx.write(`companies/${ctx.company}/signals/@${partition}/_audience.yaml`, yaml.dump({ principals: snapshot.audience, audience_source: "incremental" }));
+                const rows = [];
+                // Recover files persisted before a crash prevented the cursor/index commit.
+                // The model may correctly return no repeats, so recovery cannot depend on
+                // it returning those signals again.
+                const recovered = prior.filter((p) => p.live && !ids.has(p.signal_id)).map((p) => ({ event: "signal.written", signal_id: p.signal_id, type: p.type, source_ref: snapshot.sourceRef, company: ctx.company, key: p.key }));
+                for (const event of recovered) {
+                    ids.add(event.signal_id);
+                    if (!rows.some((row) => row.signal_id === event.signal_id))
+                        rows.push({ signal_id: event.signal_id, type: event.type, source_ref: event.source_ref, key: event.key, written_at: at });
+                }
+                for (const signal of signals) {
+                    const id = signal.update ?? signalId(snapshot.sourceRef, signal.type, signal.title);
+                    ids.add(id);
+                    const key = `${signalTypeDir(partition, signal.type)}/${id}.md`;
+                    const rel = `companies/${ctx.company}/${key}`;
+                    const file = assertAllowedPath(ctx.hqRoot, rel, { company: ctx.company });
+                    const existed = fs.existsSync(file);
+                    if (existed && !signal.update)
+                        continue;
+                    const fm = { signal_id: id, type: signal.type, source_ref: snapshot.sourceRef, canonical_content: signal.title, audience_key: partition, origin: "live", partial_revision: revision, written_at: at };
+                    ctx.write(rel, `---\n${yaml.dump(fm, { lineWidth: -1 })}---\n${signal.body}\n`);
+                    const event = { event: "signal.written", signal_id: id, type: signal.type, source_ref: snapshot.sourceRef, company: ctx.company, key };
+                    if (!existed)
+                        added.push(event);
+                    if (!rows.some((row) => row.signal_id === id))
+                        rows.push({ signal_id: id, type: signal.type, source_ref: snapshot.sourceRef, key, written_at: at });
+                }
+                await appendSignalIndex(vaultRoot, at.slice(0, 10), rows);
+                await lock.assertHeld();
+                const next = { revision, segment_count: snapshot.segmentCount, last_run_at: at, signal_ids: [...ids], digest, pending_events: [...(cursor?.pending_events ?? []), ...recovered, ...added] };
+                ctx.write(cursorPath(ctx.company, snapshot.sourceRef), `${JSON.stringify(next, null, 2)}\n`);
+                await deliver(next);
+                return { ...result, itemsOut: added.length, detail: { new_segments: Math.max(0, snapshot.segmentCount - (cursor?.segment_count ?? 0)), signals_written: added.length } };
+            }
+            finally {
+                await lock.release();
+            }
+        },
+    };
+}
+//# sourceMappingURL=incremental.js.map

package/dist/lib/signals/prior-signals.d.ts

@@ -0,0 +1,11 @@
+export interface StoredPriorSignal {
+    signal_id: string;
+    type: string;
+    title: string;
+    origin: string;
+    key: string;
+}
+export declare function priorSignalPath(hqRoot: string, company: string, key: string): string;
+export declare function findPriorSignals(hqRoot: string, company: string, sourceRef: string, now?: Date, audienceKey?: string): StoredPriorSignal[];
+export declare function normalizeSignalTitle(title: string): string;
+//# sourceMappingURL=prior-signals.d.ts.map

package/dist/lib/signals/prior-signals.js

@@ -0,0 +1,44 @@
+/** Source-scoped lookup for the final pass. Index keys are untrusted vault data. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { splitFrontmatter } from "../hot-channels/signals-pass.js";
+import { assertAllowedPath } from "./write-guard.js";
+export function priorSignalPath(hqRoot, company, key) {
+    if (!/^signals\/(?:@[a-zA-Z0-9_-]+\/)?[a-z_]+\/[a-f0-9]{64}\.md$/.test(key))
+        throw new Error("Invalid prior signal key");
+    return assertAllowedPath(hqRoot, `companies/${company}/${key}`, { company });
+}
+export function findPriorSignals(hqRoot, company, sourceRef, now = new Date(), audienceKey) {
+    const result = new Map();
+    for (let days = 0; days < 14; days++) {
+        const date = new Date(now);
+        date.setUTCDate(date.getUTCDate() - days);
+        const index = assertAllowedPath(hqRoot, `companies/${company}/signals/_index/${date.toISOString().slice(0, 10)}.json`, { company });
+        if (!fs.existsSync(index))
+            continue;
+        const rows = JSON.parse(fs.readFileSync(index, "utf8"));
+        if (!Array.isArray(rows))
+            throw new Error("Invalid signal index");
+        for (const row of rows) {
+            if (!row || row.source_ref !== sourceRef || typeof row.key !== "string" || typeof row.type !== "string" || typeof row.signal_id !== "string" || !/^[a-f0-9]{64}$/.test(row.signal_id))
+                continue;
+            const file = priorSignalPath(hqRoot, company, row.key);
+            if (!fs.existsSync(file))
+                continue;
+            const { frontmatter: fm } = splitFrontmatter(fs.readFileSync(file, "utf8"));
+            if (fm.source_ref !== sourceRef || fm.signal_id !== row.signal_id || fm.type !== row.type || path.basename(file) !== `${row.signal_id}.md`)
+                continue;
+            if (audienceKey !== undefined && fm.audience_key !== audienceKey)
+                continue;
+            const title = typeof fm.title === "string" ? fm.title : fm.canonical_content;
+            if (typeof title !== "string" || !title.trim())
+                continue;
+            result.set(row.signal_id, { signal_id: row.signal_id, type: row.type, title, origin: typeof fm.origin === "string" ? fm.origin : "", key: row.key });
+        }
+    }
+    return [...result.values()];
+}
+export function normalizeSignalTitle(title) {
+    return title.toLowerCase().replace(/\s+/g, " ").trim().replace(/[\p{P}\s]+$/gu, "");
+}
+//# sourceMappingURL=prior-signals.js.map

package/dist/lib/signals/reply.js

@@ -106,8 +106,13 @@ export function runCountItems(record, summary, opts) {
         const breakdown = [...parts].map(([k, v]) => `${k} ${v}`).join(", ");
         items.push({ key: "Sources read", value: `${plural(read, "item")}${breakdown ? ` (${breakdown})` : ""}` });
     }
-    if (extract)
+    if (extract) {
         items.push({ key: "Signals found", value: String(extract.itemsOut) });
+        const counts = extract.detail;
+        if (counts && ["new", "updated", "skipped"].every((k) => typeof counts[k] === "number")) {
+            items.push({ key: "Signal changes", value: `new: ${counts.new}, updated: ${counts.updated}, skipped: ${counts.skipped}` });
+        }
+    }
     const garden = steps(record, "garden").filter((s) => s.status !== "skipped");
     if (garden.length) {
         const tidied = garden.reduce((n, s) => n + s.itemsIn, 0);

package/dist/lib/signals/settings.d.ts

@@ -7,4 +7,9 @@ export interface SignalsSettings {
 export declare const DEFAULT_SIGNALS_SETTINGS: SignalsSettings;
 export declare const SIGNALS_SETTINGS_REL: string;
 export declare function loadSignalsSettings(hqRoot: string): SignalsSettings;
+/** Per-pass limits for a growing source; normal runs retain their own defaults. */
+export declare function loadIncrementalSettings(hqRoot: string): {
+    maxTurns: number;
+    maxBudgetUsd: number;
+};
 //# sourceMappingURL=settings.d.ts.map

package/dist/lib/signals/settings.js

@@ -45,4 +45,21 @@ export function loadSignalsSettings(hqRoot) {
     }
     return out;
 }
+/** Per-pass limits for a growing source; normal runs retain their own defaults. */
+export function loadIncrementalSettings(hqRoot) {
+    const out = { maxTurns: 12, maxBudgetUsd: 0.4 };
+    try {
+        const raw = yaml.load(fs.readFileSync(path.join(hqRoot, SIGNALS_SETTINGS_REL), "utf8"));
+        const v = raw?.incremental;
+        if (typeof v?.max_turns === "number" && VALID.maxTurns(v.max_turns))
+            out.maxTurns = v.max_turns;
+        if (typeof v?.max_budget_usd === "number" && VALID.maxBudgetUsd(v.max_budget_usd))
+            out.maxBudgetUsd = v.max_budget_usd;
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    return out;
+}
 //# sourceMappingURL=settings.js.map