@indigoai-us/hq-cli 5.345.193 → 5.345.194

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## [Unreleased]
 
+## [5.345.194] — 2026-11-03
+- Meeting and other hot-channel documents that land over the signals pass's
+  20-document limit now get signals on a later run. Before this fix, a large
+  refresh (for example 40 meetings at once) left everything past the first 20
+  without signals for good. Each run now works through the channel's backlog,
+  newest first, up to 20 documents, even when the run landed nothing new. For
+  a channel with an ontology worklist the backlog is the worklist; for a hot
+  channel without one (such as meeting pointers) the pass keeps its own queue
+  in `sources/_signals-pending/`. When there is nothing to process, claude is
+  not called.
+- New `hq sources signals --company <co> --since <date>` processes landed
+  documents from that date on that never got signals, and `--key
+  sources/<channel>/<id>.md` (repeatable) processes one again. The 20-document
+  limit still applies (`--max-docs` changes it); what it leaves stays queued
+  for the next run. `--dry-run` lists what would be queued.
+- `hq signals run --company <co> --redo sources/<channel>/<file>.md` (can be
+  repeated) processes an ontology source item again. It needs the ontology
+  worklist script with `--redo` (hq-core-staging #1781).
+- The six native hook packages (one per platform, `@indigoai-us/hq-hook-win32-x64`
+  and siblings) now publish to npm through OIDC trusted publishing without a
+  provenance statement. The v5.345.193 release failed every hook package job
+  because npm rejects provenance from a private source repository (E422), and
+  hq-cli is private. The main `@indigoai-us/hq-cli` package already publishes
+  this way.
+- `hq whoami --json` now reports the signed-in person's `personUid` (`prs_*`).
+  Person sign-in tokens carry no entity claims, so the field was always null
+  for people, and the Daily Brief read only the email-keyed signals folder and
+  missed each company's signals for that person. whoami now asks the vault for
+  the caller's person entity, the same lookup `hq secrets --personal` uses,
+  bounded to 1 second. When the lookup fails or times out, `personUid` stays
+  null and the rest of the output is unchanged. Machine (agent) identities and
+  expired sessions make no lookup.
+
 ## [5.345.193] — 2026-11-03
 - HQ's setup assistant answers the desktop app's end-of-setup handoff as the
   assistant it is: who it is and what it can help with (questions, finding

package/dist/command-catalog.generated.d.ts

@@ -5335,6 +5335,51 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly defaultValue: "<runtime-path>";
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "signals";
+        readonly description: "Process landed sources for signals again: queue them for the signals pass and run it now (the pass's document cap still applies)";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly helpOption: true;
+        readonly helpCommand: false;
+        readonly usage: "[options]";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [];
+        readonly options: readonly [{
+            readonly flags: "--company <slug>";
+            readonly description: "Company slug (defaults to .hq/config.json activeCompany)";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--since <date>";
+            readonly description: "Landed documents from this date on (YYYY-MM-DD is local midnight) that have no signals yet";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--key <key>";
+            readonly description: "A landed document to process again, signals or not (sources/<channel>/<id>.md; repeatable)";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--channel <channel>";
+            readonly description: "Limit --since to one channel";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--max-docs <n>";
+            readonly description: "Documents sent to claude in this run (default 20)";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--dry-run";
+            readonly description: "Print what would be queued; queue nothing and call no model";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--json";
+            readonly description: "Print the report as JSON";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--hq-root <path>";
+            readonly description: "Local HQ tree root (default: <runtime-path>)";
+            readonly hidden: false;
+            readonly defaultValue: "<runtime-path>";
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "sync";
         readonly description: "Run every hot channel now: each adapter once per connection you can use";
@@ -5540,6 +5585,10 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly flags: "--report-found";
             readonly description: "Print the owner's run reply only when the run found new signals; print nothing otherwise";
             readonly hidden: false;
+        }, {
+            readonly flags: "--redo <file>";
+            readonly description: "Process a source item again (sources/<channel>/<file>.md; repeatable; needs --company): the extract step re-queues it in the ontology worklist before listing";
+            readonly hidden: false;
         }, {
             readonly flags: "--hq-root <path>";
             readonly description: "HQ root (default: <runtime-path>)";

package/dist/command-catalog.generated.js

@@ -6471,6 +6471,61 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "signals",
+                "description": "Process landed sources for signals again: queue them for the signals pass and run it now (the pass's document cap still applies)",
+                "aliases": [],
+                "hidden": false,
+                "helpOption": true,
+                "helpCommand": false,
+                "usage": "[options]",
+                "helpText": [],
+                "arguments": [],
+                "options": [
+                    {
+                        "flags": "--company <slug>",
+                        "description": "Company slug (defaults to .hq/config.json activeCompany)",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--since <date>",
+                        "description": "Landed documents from this date on (YYYY-MM-DD is local midnight) that have no signals yet",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--key <key>",
+                        "description": "A landed document to process again, signals or not (sources/<channel>/<id>.md; repeatable)",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--channel <channel>",
+                        "description": "Limit --since to one channel",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--max-docs <n>",
+                        "description": "Documents sent to claude in this run (default 20)",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--dry-run",
+                        "description": "Print what would be queued; queue nothing and call no model",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "Print the report as JSON",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--hq-root <path>",
+                        "description": "Local HQ tree root (default: <runtime-path>)",
+                        "hidden": false,
+                        "defaultValue": "<runtime-path>"
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "sync",
                 "description": "Run every hot channel now: each adapter once per connection you can use",
@@ -6728,6 +6783,11 @@ export const COMMAND_CATALOG = [
                         "description": "Print the owner's run reply only when the run found new signals; print nothing otherwise",
                         "hidden": false
                     },
+                    {
+                        "flags": "--redo <file>",
+                        "description": "Process a source item again (sources/<channel>/<file>.md; repeatable; needs --company): the extract step re-queues it in the ontology worklist before listing",
+                        "hidden": false
+                    },
                     {
                         "flags": "--hq-root <path>",
                         "description": "HQ root (default: <runtime-path>)",

package/dist/commands/signals-run.d.ts

@@ -21,6 +21,7 @@ interface RunCliOptions {
     maxBudgetUsd?: number;
     json?: boolean;
     reportFound?: boolean;
+    redo?: string[];
     hqRoot: string;
 }
 export declare function formatRunResult(result: RunSignalsResult, dryRun: boolean): string;

package/dist/commands/signals-run.js

@@ -19,6 +19,9 @@ function parsePositiveInt(v) {
         throw new InvalidArgumentError("must be a positive integer");
     return n;
 }
+function collectRedo(v, prev = []) {
+    return [...prev, v];
+}
 function parseNonNegative(v) {
     const n = Number(v);
     if (!Number.isFinite(n) || n < 0)
@@ -113,6 +116,7 @@ export async function runSignalsCli(options, overrides = {}) {
         catchUp: options.catchUp === true || envCatchUp(),
         maxTurns: options.maxTurns,
         maxBudgetUsd: options.maxBudgetUsd,
+        ...(options.redo?.length ? { redo: options.redo } : {}),
         signalsAlert: overrides.signalsAlert ?? terminalSignalsAlert(),
     });
     const code = signalsExitCode(result);
@@ -155,6 +159,7 @@ export function registerSignalsRunSubcommand(signals) {
         .option("--max-budget-usd <x>", "Spend cap in USD for the extract step (default from core/settings/signals.yaml, else 2.00)", parseNonNegative)
         .option("--json", "Print the run record as JSON")
         .option("--report-found", "Print the owner's run reply only when the run found new signals; print nothing otherwise")
+        .option("--redo <file>", "Process a source item again (sources/<channel>/<file>.md; repeatable; needs --company): the extract step re-queues it in the ontology worklist before listing", collectRedo)
         .option("--hq-root <path>", `HQ root (default: ${DEFAULT_HQ_ROOT})`, DEFAULT_HQ_ROOT)
         .action(async (options) => {
         try {

package/dist/commands/sources.d.ts

@@ -128,6 +128,53 @@ export declare function runCompanyHotChannelSync(input: CompanyHotChannelSyncInp
  * line under `companies/{company}/sources/`, and nothing else.
  */
 export declare function runSync(options: SyncOptions, overrides?: SyncOverrides): Promise<OnDemandSyncReport>;
+export interface SignalsRedoOptions {
+    company?: string;
+    since?: string;
+    key?: string[];
+    channel?: string;
+    maxDocs?: number;
+    dryRun?: boolean;
+    json?: boolean;
+    hqRoot: string;
+}
+export interface SignalsRedoOverrides {
+    now?: () => Date;
+    /** The signed-in person; defaults to the local Cognito session. */
+    author?: {
+        email: string;
+    } | null;
+    /** The signals pass; defaults to the local `claude -p` pass with `maxDocs`. */
+    createPass?: (maxDocs: number) => SignalsGeneratedFn;
+    worklistScript?: string;
+}
+export interface SignalsRedoReport {
+    company: string;
+    dryRun: boolean;
+    /** Keys queued per channel, by how they were queued. */
+    queued: {
+        pending: Record<string, string[]>;
+        worklist: Record<string, string[]>;
+    };
+    signalsWritten: number;
+    /** Keys still waiting in each channel's pending file after the run. */
+    pendingLeft: Record<string, number>;
+    notices: string[];
+    error: string | null;
+    exitCode: number;
+}
+/**
+ * `hq sources signals`: queue landed documents for the signals pass and run
+ * the pass now, under the same per-person lock as `hq sources sync`. The pass
+ * keeps its cap (`--max-docs`, default 20); what the cap leaves stays queued
+ * and the next run (this command or the daily sync) picks it up.
+ */
+export declare function runSignalsRedo(options: SignalsRedoOptions, overrides?: SignalsRedoOverrides): Promise<SignalsRedoReport>;
+/** A usage or setup failure `runSignalsRedo` already printed; the exit code is set. */
+export declare class SignalsRedoExit extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode: number);
+}
 export interface ScheduleOptions {
     company?: string;
     at?: string;

package/dist/commands/sources.js

@@ -23,6 +23,7 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { InvalidArgumentError } from "commander";
 import chalk from "chalk";
 import { SOURCE_CHANNELS, assertSourceChannel, resolveEntity, listAvailableEntities, listSources, getSource, VaultClient, } from "@indigoai-us/hq-cloud";
 import { ensureCognitoToken, ensureCognitoIdToken, buildVaultConfig, DEFAULT_COGNITO, DEFAULT_HQ_ROOT, } from "../utils/cognito-session.js";
@@ -34,7 +35,8 @@ import { resolveUploadAuthor } from "../utils/upload-author.js";
 import { createSignalsAlertChannelPoster, raiseSignalsFailureAlerts } from "../lib/hot-channels/alert.js";
 import { audienceKey } from "../lib/hot-channels/audience.js";
 import { appendRunLedgerEntry, ledgerDay, readRunLedger, summarizeRunLedger, } from "../lib/hot-channels/ledger.js";
-import { createClaudeSignalsPass } from "../lib/hot-channels/signals-pass.js";
+import { createClaudeSignalsPass, DEFAULT_MAX_SIGNAL_DOCS, readPendingSignals, SignalsPassError, } from "../lib/hot-channels/signals-pass.js";
+import { backlogRunResult, parseSince, queueSignalsRedo, selectSignalsRedo, SignalsRedoUsageError, } from "../lib/hot-channels/signals-redo.js";
 import { assertSafeSegment } from "../lib/hot-channels/landing.js";
 import { acquireSyncLock, SYNC_LOCK_BUSY_REASON } from "../lib/hot-channels/sync-lock.js";
 import { createBuiltinHotChannelRegistry } from "../lib/hot-channels/adapters/index.js";
@@ -642,6 +644,139 @@ function renderSyncTable(company, report) {
     }
     return lines.join("\n");
 }
+/**
+ * `hq sources signals`: queue landed documents for the signals pass and run
+ * the pass now, under the same per-person lock as `hq sources sync`. The pass
+ * keeps its cap (`--max-docs`, default 20); what the cap leaves stays queued
+ * and the next run (this command or the daily sync) picks it up.
+ */
+export async function runSignalsRedo(options, overrides = {}) {
+    const company = options.company ?? readActiveCompanySlug(options.hqRoot);
+    const fail = (message, exitCode) => {
+        process.stderr.write(chalk.red(`✗ ${message}\n`));
+        process.exitCode = exitCode;
+        throw new SignalsRedoExit(message, exitCode);
+    };
+    if (!company)
+        return fail("No company specified. Pass --company <slug> or set activeCompany in .hq/config.json.", 2);
+    assertSafeSegment(company, "company");
+    if (options.since === undefined && (options.key ?? []).length === 0)
+        return fail("Pass --since <date> or --key <sources/channel/id.md>.", 2);
+    const vaultRoot = path.join(options.hqRoot, "companies", company);
+    if (!fs.existsSync(vaultRoot))
+        return fail(`No company directory: companies/${company}`, 2);
+    const maxDocs = options.maxDocs ?? DEFAULT_MAX_SIGNAL_DOCS;
+    let selection;
+    try {
+        selection = await selectSignalsRedo({
+            vaultRoot,
+            ...(options.key ? { keys: options.key } : {}),
+            ...(options.since !== undefined ? { since: parseSince(options.since) } : {}),
+            ...(options.channel !== undefined ? { channel: options.channel } : {}),
+        });
+    }
+    catch (err) {
+        if (err instanceof SignalsRedoUsageError)
+            return fail(err.message, 2);
+        throw err;
+    }
+    const report = {
+        company,
+        dryRun: options.dryRun === true,
+        queued: { pending: Object.fromEntries(selection.pending), worklist: Object.fromEntries(selection.worklist) },
+        signalsWritten: 0,
+        pendingLeft: {},
+        notices: [...selection.notices],
+        error: null,
+        exitCode: 0,
+    };
+    const channels = [...new Set([...selection.pending.keys(), ...selection.worklist.keys()])];
+    if (!report.dryRun && channels.length > 0) {
+        const author = overrides.author !== undefined ? overrides.author : resolveUploadAuthor();
+        if (!author)
+            return fail(`${SIGN_IN_PROMPT} (the run takes your hot-channel sync lock)`, 1);
+        const lock = await acquireSyncLock(vaultRoot, audienceKey([author.email]), overrides.now ? { now: overrides.now } : {});
+        if (!lock)
+            return fail(`Another hot-channel sync for ${company} is running. Try again when it finishes.`, 1);
+        try {
+            await queueSignalsRedo({
+                hqRoot: options.hqRoot,
+                company,
+                selection,
+                beforeWrite: lock.assertHeld,
+                ...(overrides.worklistScript ? { worklistScript: overrides.worklistScript } : {}),
+            });
+            const pass = overrides.createPass
+                ? overrides.createPass(maxDocs)
+                : createClaudeSignalsPass({ hqRoot: options.hqRoot, company, maxDocs });
+            for (const channel of channels) {
+                report.signalsWritten += await pass(backlogRunResult(channel), { beforeWrite: lock.assertHeld });
+            }
+        }
+        catch (err) {
+            report.error = err instanceof SignalsPassError ? err.code : err instanceof Error ? err.message : String(err);
+            report.exitCode = 1;
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    for (const channel of selection.pending.keys()) {
+        report.pendingLeft[channel] = (await readPendingSignals(vaultRoot, channel)).length;
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`${renderSignalsRedo(report)}\n`);
+    }
+    if (report.exitCode !== 0)
+        process.exitCode = report.exitCode;
+    return report;
+}
+/** A usage or setup failure `runSignalsRedo` already printed; the exit code is set. */
+export class SignalsRedoExit extends Error {
+    exitCode;
+    constructor(message, exitCode) {
+        super(message);
+        this.name = "SignalsRedoExit";
+        this.exitCode = exitCode;
+    }
+}
+function renderSignalsRedo(report) {
+    const lines = [`${report.dryRun ? "Would queue" : "Queued"} for signals in ${report.company}:`];
+    const groups = [
+        ...Object.entries(report.queued.pending).map(([channel, keys]) => ({ channel, keys, how: "pending" })),
+        ...Object.entries(report.queued.worklist).map(([channel, keys]) => ({ channel, keys, how: "worklist --redo" })),
+    ];
+    if (groups.length === 0)
+        lines.push("  nothing (no matching landed document without signals)");
+    for (const group of groups) {
+        lines.push(`  sources/${group.channel}: ${group.keys.length} (${group.how})`);
+        for (const key of group.keys)
+            lines.push(`    ${key}`);
+    }
+    lines.push(...report.notices);
+    if (!report.dryRun && groups.length > 0) {
+        lines.push("", `${report.signalsWritten} signal(s) written.`);
+        for (const [channel, left] of Object.entries(report.pendingLeft)) {
+            if (left > 0)
+                lines.push(`${left} document(s) still queued in sources/${channel}; the next run picks them up.`);
+        }
+        if (report.error)
+            lines.push(chalk.red(`The signals pass stopped: ${report.error}. Queued documents stay queued.`));
+    }
+    return lines.join("\n");
+}
+function collectKey(value, previous = []) {
+    return [...previous, value];
+}
+function parseMaxDocs(value) {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n <= 0)
+        throw new InvalidArgumentError("must be a positive integer");
+    return n;
+}
 function fleetBotsIn(root) {
     let names;
     try {
@@ -842,6 +977,27 @@ export function registerSourcesCommand(program) {
         .action(withErrorHandling(async (options) => {
         await runSchedule(options);
     }));
+    sources
+        .command("signals")
+        .description("Process landed sources for signals again: queue them for the signals pass and run it now (the pass's document cap still applies)")
+        .option("--company <slug>", "Company slug (defaults to .hq/config.json activeCompany)")
+        .option("--since <date>", "Landed documents from this date on (YYYY-MM-DD is local midnight) that have no signals yet")
+        .option("--key <key>", "A landed document to process again, signals or not (sources/<channel>/<id>.md; repeatable)", collectKey)
+        .option("--channel <channel>", "Limit --since to one channel")
+        .option("--max-docs <n>", `Documents sent to claude in this run (default ${DEFAULT_MAX_SIGNAL_DOCS})`, parseMaxDocs)
+        .option("--dry-run", "Print what would be queued; queue nothing and call no model")
+        .option("--json", "Print the report as JSON")
+        .option("--hq-root <path>", `Local HQ tree root (default: ${DEFAULT_HQ_ROOT})`, DEFAULT_HQ_ROOT)
+        .action(withErrorHandling(async (options) => {
+        try {
+            await runSignalsRedo(options);
+        }
+        catch (err) {
+            // Usage and setup failures are already printed with their exit code.
+            if (!(err instanceof SignalsRedoExit))
+                throw err;
+        }
+    }));
     sources
         .command("sync")
         .description("Run every hot channel now: each adapter once per connection you can use")

package/dist/commands/whoami.d.ts

@@ -21,6 +21,13 @@ export interface WhoamiDisplayIdentity {
  * email with the token subject of the delegating machine.
  */
 export declare function resolveWhoamiIdentity(identity: WhoamiTokenIdentity): WhoamiDisplayIdentity;
+/**
+ * Bound on the person-uid lookup, so `--json` callers with short timeouts still
+ * get an answer. Kept at 1s: with every endpoint stalled, a whole `whoami
+ * --json` must still finish inside the foreground network budget plus startup
+ * (foreground-network-budget.test.ts); 3s overran it.
+ */
+export declare const PERSON_UID_LOOKUP_TIMEOUT_MS = 1000;
 export declare function renderWhoamiPlanBlock(status: PlanLimitStatus, opts?: {
     inviteTeammateEnabled?: boolean;
 }): string | null;

package/dist/commands/whoami.js

@@ -8,6 +8,7 @@ import { ensureCognitoToken, loadMachineCachedTokens, resolveCognitoTokenSource,
 import { colorizePlanLimitNotice, fetchPlanLimitStatus, renderPlanLine, renderPlanLimitNotice, } from "../lib/billing/plan-lock.js";
 import { resolveCompanyFlagGate, } from "../lib/flag-registry.js";
 import { queuePlanLimitInviteTeammateExposure } from "../utils/cli-telemetry.js";
+import { resolveCallerPersonUid } from "../utils/vault-api.js";
 export const CLI_LIMIT_INVITE_TEAMMATE_FLAG = "cli.limit-invite-teammate-v1";
 /**
  * Resolves the person represented by an ID token without pairing a delegated
@@ -44,6 +45,36 @@ function peekIdToken(idToken) {
             : undefined,
     };
 }
+/**
+ * Bound on the person-uid lookup, so `--json` callers with short timeouts still
+ * get an answer. Kept at 1s: with every endpoint stalled, a whole `whoami
+ * --json` must still finish inside the foreground network budget plus startup
+ * (foreground-network-budget.test.ts); 3s overran it.
+ */
+export const PERSON_UID_LOOKUP_TIMEOUT_MS = 1_000;
+/**
+ * The signed-in person's canonical `prs_*` uid for `whoami --json`. Person ID
+ * tokens carry no `custom:entityType`/`custom:entityUid` claims, so the token
+ * alone almost never has it; the vault's person-entity lookup does (the same
+ * rule `hq secrets --personal` uses). Best-effort: no session, a timeout or a
+ * network failure resolve to null and the rest of the identity still prints.
+ */
+async function readPersonUid(identity) {
+    if (identity.entityType === 'person' && identity.entityUid)
+        return identity.entityUid;
+    try {
+        const token = await ensureCognitoToken({ interactive: false });
+        if (!token)
+            return null;
+        return await resolveCallerPersonUid(token, undefined, {
+            command: 'hq whoami',
+            signal: AbortSignal.timeout(PERSON_UID_LOOKUP_TIMEOUT_MS),
+        });
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * starter-plan-hard-limits / US-011 — read the workspace plan-limit nag for
  * `--company <slug>` (the bind notice).
@@ -148,9 +179,11 @@ export function registerWhoamiCommand(program) {
                     : boundLegacyAgent;
                 // planLimits is additive: absent-or-null means UNKNOWN.
                 const planLimits = await readPlanLimits(opts.company);
+                const authenticated = machine ? Boolean(machineCreds) : Boolean(cached && !isExpiring(cached, 0));
+                const personUid = !machine && authenticated ? await readPersonUid(identity) : null;
                 console.log(JSON.stringify({
                     schemaVersion: 1,
-                    authenticated: machine ? Boolean(machineCreds) : Boolean(cached && !isExpiring(cached, 0)),
+                    authenticated,
                     tokenSource: machine ? 'machine' : 'person',
                     email: machine ? null : displayedIdentity.email ?? null,
                     // Cognito subject of the person shown in `email` (null for machine
@@ -162,7 +195,7 @@ export function registerWhoamiCommand(program) {
                         ? identity.delegatedEmail : null,
                     delegatedSub: identity.delegatedEmail !== undefined && identity.delegatedSub !== undefined
                         ? identity.delegatedSub : null,
-                    personUid: !machine && identity.entityType === 'person' ? identity.entityUid ?? null : null,
+                    personUid,
                     agentUid,
                     username: machineCreds?.username ?? null,
                     planLimits,

package/dist/lib/hot-channels/loop.d.ts

@@ -12,6 +12,12 @@ export interface HotChannelRunResult {
     /** Adapter id, or the catalog provider when it did not resolve. */
     adapterId: string;
     provider: string;
+    /**
+     * The adapter's channel (`sources/{channel}/`). Set once the adapter
+     * resolves, so the signals pass can drain that channel's worklist even
+     * when the run landed nothing.
+     */
+    channel?: string;
     /** The connection this run used; null for a channel with no connection. */
     connectionId: string | null;
     transport: HotTransport | null;

package/dist/lib/hot-channels/loop.js

@@ -209,6 +209,7 @@ export async function runHotChannelLoop(input) {
         try {
             const adapter = input.registry.resolve(entry);
             result.adapterId = adapter.id;
+            result.channel = adapter.channel;
             result.transport = adapter.transport;
             if (adapter.transport === "push") {
                 await drainPush(ctx, adapter, result);

package/dist/lib/hot-channels/signals-pass.d.ts

@@ -1,9 +1,22 @@
 /**
- * The local signals pass (US-011). After a hot-channel run lands sources, the
- * pass takes the run's landed documents through the ontology worklist, asks
+ * The local signals pass (US-011). After each hot-channel adapter run, the
+ * pass takes the adapter's channel through the ontology worklist, asks
  * `claude -p` for signals one document at a time, and writes those signals to
  * `companies/{co}/signals/`. It returns the count for the run ledger.
  *
+ * Work comes from the worklist, not only from this run's landings: when the
+ * worklist script exits 0, the pass takes the channel's unprocessed items in
+ * the worklist's order (newest first) up to the run's document cap. Items the
+ * cap leaves over stay unmarked, and a later run picks them up, including a
+ * run that landed nothing (a bounded backlog drain: at most
+ * DEFAULT_MAX_SIGNAL_DOCS claude calls per run, and no claude call at all when
+ * the backlog is empty). A channel with no source.yaml (worklist exit 2, the
+ * usual case for a hot channel such as `meeting-events`) has no worklist, so
+ * the pass keeps its own backlog: landed documents it has not processed yet
+ * are listed in `sources/_signals-pending/{channel}.json` and drained, newest
+ * first by `when` (else `created_at`), on later runs under the same cap. A
+ * cloud-run source (exit 4) is skipped.
+ *
  * A landed document with both `payload_ref` and `raw_ref` is a pointer (the
  * meetings, Slack and Attio adapters land these). For it, claude gets the
  * pointer followed by the document `payload_ref` names, capped at
@@ -118,6 +131,24 @@ interface ParsedSignal {
 }
 export declare function defaultPromptFile(): string;
 export declare const CLAUDE_LOGGED_OUT_RE: RegExp;
+export declare function channelOf(key: string): string | null;
+/**
+ * Vault-relative file that lists a channel's landed documents the pass has not
+ * processed yet. Only channels with no worklist (no source.yaml) use it.
+ */
+export declare function pendingSignalsKey(channel: string): string;
+/** The channel's pending landed keys; a missing or unreadable file is an empty backlog. */
+export declare function readPendingSignals(vaultRoot: string, channel: string): Promise<string[]>;
+/** Replace the channel's pending list; an empty list removes the file. */
+export declare function writePendingSignals(vaultRoot: string, channel: string, keys: readonly string[], beforeWrite?: () => Promise<void>): Promise<void>;
+/** Add landed keys to the channel's pending list (kept once each). */
+export declare function queuePendingSignals(vaultRoot: string, channel: string, keys: readonly string[], beforeWrite?: () => Promise<void>): Promise<void>;
+/** When a landed document happened: `when`, else `created_at`; unknown sorts last. */
+export declare function landedDocTime(frontmatter: Record<string, unknown>): number;
+export declare function splitFrontmatter(text: string): {
+    frontmatter: Record<string, unknown>;
+    body: string;
+};
 /**
  * The text claude gets for one landed document. A pointer (both `payload_ref`
  * and `raw_ref` set) gets its payload appended after a separator line. Any