@telora/daemon 0.22.245 → 0.22.290

package/dist/queries/focus-debug-artifacts/focus-integration-conflict.js

@@ -0,0 +1,121 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/git/focus-integration-sync.test.ts,
+//   packages/daemon/src/queries/focus-debug-artifacts/focus-integration-conflict.test.ts,
+//   packages/daemon/src/spawn/integration-reconcile-spawn.test.ts
+// PINNED-BY-END
+/**
+ * The focus's durable record of "my branch conflicts with integration", and its
+ * clear.
+ *
+ * WHERE IT LIVES, AND WHY NOT THE DELIVERIES' GIT STATE. `org_nodes.git_state`
+ * is a FORWARD-ONLY ladder (git/state-detector.ts GIT_STATE_PRIORITY: a
+ * delivery's state only ever advances) with ONE slot per delivery. A spawn-time
+ * conflict is neither a forward step nor a delivery fact -- it is a fact about
+ * the focus BRANCH, shared by every delivery on it -- and clearing it would mean
+ * writing the ladder BACKWARDS to a value the daemon would first have to
+ * remember. It also carries no room for the paths or the commits behind the
+ * divergence, and adding a state widens a three-place vocabulary (the PG check
+ * constraint, GIT_STATES, DELIVERY_GIT_STATE) whose existing conflict states
+ * (`merge_conflict`, `resolving_conflict`) the dashboard and delivery-transitions
+ * already read as the COMPLETION merge.
+ *
+ * So the record is a focus_debug_artifacts section instead: one row per (focus,
+ * section_kind), already rendered on the focus Debug tab with its own
+ * "Updated ..." stamp, read by nothing in the machine's decision path -- so
+ * recording here cannot misroute a delivery -- and cleared by DELETING the row,
+ * which is exactly the shape "until a sync succeeds" wants.
+ *
+ * SINCE-WHEN SURVIVES THE RE-RECORD. `updated_at` moves on every re-write, and
+ * a conflicting branch is re-recorded on every spawn, so `updated_at` alone
+ * would always read "just now" and hide how long a divergence has persisted.
+ * The content therefore carries `Conflicting since:` explicitly, and a
+ * re-record READS the existing section and carries its value forward. A failed
+ * read degrades to "since now" rather than losing the record.
+ *
+ * History: docs/daemon/history-platform.md (queries/focus-debug-artifacts/focus-integration-conflict.ts).
+ */
+import { callApi } from '../api-client/shared.js';
+/** The focus_debug_artifacts section the record lives in. */
+export const INTEGRATION_SYNC_SECTION_KIND = 'integration_sync';
+/** The line carrying the first-observed timestamp across re-records. */
+export const CONFLICTING_SINCE_PREFIX = 'Conflicting since: ';
+/**
+ * Render the human-facing record. The first-observed timestamp is the one line
+ * a re-record must be able to find again, so it is emitted on its own line with
+ * a fixed prefix (parseConflictingSince reads it back).
+ */
+export function renderIntegrationConflictArtifact(args) {
+    const { focusName, branchName, conflict, since } = args;
+    const list = (items, empty) => items.length > 0 ? items.map(i => `- ${i}`) : [`- ${empty}`];
+    return [
+        `# Branch conflicts with \`${conflict.integrationBranch}\``,
+        '',
+        `The focus branch \`${branchName}\` cannot be brought current with \`${conflict.integrationBranch}\`:`,
+        'the coding spawn\'s sync rebase conflicts and is aborted, so the branch keeps building',
+        'on a stale base. The coding team is given reconciling with integration as its first',
+        'task on every spawn until a sync succeeds; this record clears then.',
+        '',
+        `${CONFLICTING_SINCE_PREFIX}${since}`,
+        `Last observed: ${conflict.detectedAt}`,
+        `Focus: ${focusName}`,
+        '',
+        `## Conflicting paths (${conflict.conflictPaths.length})`,
+        '',
+        ...list(conflict.conflictPaths, '(unmerged-path read failed)'),
+        '',
+        `## Commits on \`${conflict.integrationBranch}\` the branch lacks (${conflict.missingCommits.length})`,
+        '',
+        ...list(conflict.missingCommits, '(commit read failed)'),
+    ].join('\n');
+}
+/** The `Conflicting since:` value in a stored artifact, or null when absent. */
+export function parseConflictingSince(content) {
+    if (!content)
+        return null;
+    for (const line of content.split('\n')) {
+        if (line.startsWith(CONFLICTING_SINCE_PREFIX)) {
+            const value = line.slice(CONFLICTING_SINCE_PREFIX.length).trim();
+            if (value)
+                return value;
+        }
+    }
+    return null;
+}
+/** The first-observed timestamp already on record for this focus, or null. */
+async function readConflictingSince(focusId) {
+    const result = await callApi('focus_debug_get', { focusId });
+    const section = (result?.sections ?? []).find(s => s.sectionKind === INTEGRATION_SYNC_SECTION_KIND);
+    return parseConflictingSince(section?.content);
+}
+/**
+ * Record that this focus's branch conflicts with integration, carrying forward
+ * the first-observed timestamp when one is already on record.
+ */
+export async function recordFocusIntegrationConflict(args) {
+    const { focusId, focusName, branchName, conflict } = args;
+    let since = null;
+    try {
+        since = await readConflictingSince(focusId);
+    }
+    catch {
+        // A failed read costs the ORIGINAL since-when, never the record itself.
+        since = null;
+    }
+    await callApi('focus_debug_set', {
+        focusId,
+        fields: {
+            sectionKind: INTEGRATION_SYNC_SECTION_KIND,
+            content: renderIntegrationConflictArtifact({
+                focusName, branchName, conflict, since: since ?? conflict.detectedAt,
+            }),
+        },
+    });
+}
+/** Clear the record. Idempotent: deleting a section that is not there is a no-op. */
+export async function clearFocusIntegrationConflict(focusId) {
+    await callApi('focus_debug_clear', {
+        focusId,
+        fields: { sectionKind: INTEGRATION_SYNC_SECTION_KIND },
+    });
+}
+//# sourceMappingURL=focus-integration-conflict.js.map

package/dist/queries/focus-debug-artifacts/focus-integration-conflict.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-integration-conflict.js","sourceRoot":"","sources":["../../../src/queries/focus-debug-artifacts/focus-integration-conflict.ts"],"names":[],"mappings":"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"}

package/dist/queries/focus-debug-artifacts/focus-unclaimed-migration.d.ts

@@ -0,0 +1,116 @@
+import type { UnclaimedFile } from '../../migrations/migration-claim-lifecycle.js';
+/** The focus_debug_artifacts section the record lives in. */
+export declare const UNCLAIMED_MIGRATION_SECTION_KIND = "unclaimed_migration";
+/** The line carrying the first-observed timestamp across re-records. */
+export declare const UNCLAIMED_SINCE_PREFIX = "Unclaimed since: ";
+/**
+ * The line recording that this record has been PUT IN FRONT OF THE TEAM.
+ *
+ * WHY THE RECORD IS NOT ENOUGH ON ITS OWN. A record that nobody reads before
+ * the branch merges is a note written to an empty room: the file lands on
+ * integration holding a number no claim knows about, and the team that wrote it
+ * has finished. So an unnamed record is TEAM-ACTIONABLE WORK -- the completion
+ * path treats it the way it treats an outstanding merge-conflict resolution,
+ * and the team is not torn down before it has been handed the file.
+ *
+ * WHY IT IS MARKED, AND WHY THAT BOUNDS IT. The hold lasts exactly one coding
+ * turn: once the record has been composed into a spawn prompt, this line is
+ * written and the hold lifts, whether or not the team acted. A hold that
+ * persisted until the team complied would be a wedge -- the record clears only
+ * on a claim or a removal, and neither is something the daemon can force.
+ * Telling the team once is what was missing; compelling it is not this
+ * mechanism's business.
+ */
+export declare const UNCLAIMED_NAMED_PREFIX = "Named to the team at: ";
+/** Render the human-facing record. */
+export declare function renderUnclaimedMigrationArtifact(args: {
+    focusName: string;
+    branchName: string;
+    files: readonly UnclaimedFile[];
+    since: string;
+    /** When the team was handed this record, if it has been. */
+    namedAt?: string | null;
+}): string;
+/** When an existing record was last put in front of the team, or null. */
+export declare function parseUnclaimedNamedAt(content: string | null | undefined): string | null;
+/** Read the first-observed timestamp back out of an existing record. */
+export declare function parseUnclaimedSince(content: string | undefined): string | null;
+/**
+ * Record that this focus's branch holds unclaimed migrations, carrying forward
+ * the first-observed timestamp when one is already on record.
+ */
+export declare function recordUnclaimedMigrations(args: {
+    focusId: string;
+    focusName: string;
+    branchName: string;
+    files: readonly UnclaimedFile[];
+    detectedAt: string;
+}): Promise<void>;
+/** Clear the record. Idempotent: deleting a section that is not there is a no-op. */
+export declare function clearUnclaimedMigrations(focusId: string): Promise<void>;
+/**
+ * Read the record back, for the spawn prompt.
+ *
+ * Returns the rendered content, or null when the focus has no such record.
+ * The section is stored as prose because it is also a human-facing Debug-tab
+ * artifact; the prompt carries the same text rather than re-rendering it, so a
+ * team and a human read the identical account.
+ */
+export declare function readUnclaimedMigrationRecord(focusId: string): Promise<string | null>;
+/**
+ * The same read, but a FAILURE THROWS.
+ *
+ * Two callers need the difference. A spawn must never be failed by a debug-tab
+ * read, so it takes the lenient form above. The completion path must not read
+ * a failed read as "there is nothing to tell" -- that is the destructive
+ * direction, the one that lets a team go with an unclaimed migration still on
+ * its branch -- so it takes this one and fails closed. Swallowing inside the
+ * query made both callers the same, and quietly defeated the second one's
+ * fail-closed handler: it could never see the failure it was written for.
+ */
+export declare function readUnclaimedMigrationRecordStrict(focusId: string): Promise<string | null>;
+/**
+ * The ordinals an existing record names.
+ *
+ * Read back so the lifecycle can keep an ordinal NAMED until the team resolves
+ * it. Without this the record clears the moment the branch merges -- its own
+ * unclaimed file then reads as inherited from integration, the detection goes
+ * quiet, and the record reports success for a problem that only moved.
+ *
+ * Parsed from the rendered lines rather than stored twice: one text is what a
+ * human reads on the Debug tab AND what the team is shown, and a second
+ * machine-readable copy is a second thing to keep in step.
+ */
+export declare function parseUnclaimedOrdinals(content: string | null | undefined): string[];
+/** One migration an existing record names: its number and the file it named. */
+export interface RecordedUnclaimedEntry {
+    ordinal: string;
+    path: string;
+}
+/**
+ * The record's entries, WITH their paths.
+ *
+ * The ordinals alone are not enough to re-render the record. When integration
+ * cannot be read, an ordinal the branch no longer shows can be neither proved
+ * merged nor proved removed -- so it must be carried forward verbatim, and
+ * carrying it forward needs the file it named. Reading it back from the record
+ * (rather than storing a second machine-readable copy) keeps one text as both
+ * what a human reads and what the lifecycle reasons over.
+ */
+export declare function parseUnclaimedEntries(content: string | null | undefined): RecordedUnclaimedEntry[];
+/**
+ * Mark this focus's record as having been handed to the team.
+ *
+ * Called when the record is composed into a spawn prompt -- the moment the team
+ * is actually told. Writing it earlier (at detection) would lift the hold
+ * before anyone read it; writing it later (after the session ends) would hold a
+ * second turn for a file already named.
+ *
+ * Best effort by construction: a spawn is never failed by this write. The cost
+ * of losing it is one extra coding turn, and the cost of the whole mechanism
+ * failing is what it was before -- the team is still shown the record on every
+ * spawn while it stands, because the section renders on the record's existence,
+ * not on this marker.
+ */
+export declare function markUnclaimedMigrationNamed(focusId: string, namedAt: string): Promise<void>;
+//# sourceMappingURL=focus-unclaimed-migration.d.ts.map

package/dist/queries/focus-debug-artifacts/focus-unclaimed-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-unclaimed-migration.d.ts","sourceRoot":"","sources":["../../../src/queries/focus-debug-artifacts/focus-unclaimed-migration.ts"],"names":[],"mappings":"AAuCA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+CAA+C,CAAC;AAEnF,6DAA6D;AAC7D,eAAO,MAAM,gCAAgC,wBAAwB,CAAC;AAEtE,wEAAwE;AACxE,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAE1D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,sBAAsB,2BAA2B,CAAC;AAQ/D,sCAAsC;AACtC,wBAAgB,gCAAgC,CAAC,IAAI,EAAE;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,GAAG,MAAM,CAwBT;AAED,0EAA0E;AAC1E,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CASvF;AAED,wEAAwE;AACxE,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAS9E;AASD;;;GAGG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE;IACJ,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB,GACA,OAAO,CAAC,IAAI,CAAC,CA6Bf;AAED,qFAAqF;AACrF,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAKf;AAED;;;;;;;GAOG;AACH,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAQxB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAKxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,EAAE,CAEnF;AAED,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACjC,sBAAsB,EAAE,CAQ1B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAef"}

package/dist/queries/focus-debug-artifacts/focus-unclaimed-migration.js

@@ -0,0 +1,263 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/completion-event/exit-unclaimed-migration-hold.test.ts,
+//   packages/daemon/src/completion/completion-event/unclaimed-migration-notice.test.ts,
+//   packages/daemon/src/migrations/claim-production-wiring.test.ts,
+//   packages/daemon/src/queries/focus-debug-artifacts/focus-unclaimed-migration.test.ts,
+//   packages/daemon/src/spawn/migration-numbering-wiring.test.ts
+// PINNED-BY-END
+/**
+ * The focus's durable record of "my branch holds a migration I never claimed",
+ * and its clear.
+ *
+ * WHY THIS IS STATE AND NOT AN ESCALATION. It names no human-only act: the team
+ * that wrote the file is the one that can claim the number or remove it. An
+ * escalation would be a row in a human queue that can only wait for the same
+ * team to act, and a routine triage pass could resolve it while the file is
+ * still unclaimed. So it is a fact about the focus that clears itself when the
+ * fact stops being true.
+ *
+ * WHY focus_debug_artifacts, and not the deliveries' git_state: the same reason
+ * `focus-integration-conflict.ts` gives. `org_nodes.git_state` is a
+ * forward-only ladder with one slot per delivery, and this is a fact about the
+ * focus BRANCH shared by every delivery on it -- with no room for the number or
+ * the path. A debug section is one row per (focus, kind), rendered with its own
+ * stamp, read by nothing in the machine's decision path, and cleared by
+ * DELETING the row, which is exactly what "until the team claims or removes it"
+ * wants.
+ *
+ * SINCE-WHEN SURVIVES THE RE-RECORD. `updated_at` moves on every write and the
+ * record is re-written on every pass that still sees the file, so `updated_at`
+ * alone would always read "just now" and hide a file unclaimed for a week. The
+ * content carries `Unclaimed since:` explicitly and a re-record reads the
+ * existing section and carries the value forward; a failed read degrades to
+ * "since now" rather than losing the record.
+ *
+ * @module queries/focus-debug-artifacts/focus-unclaimed-migration
+ */
+import { callApi } from '../api-client/shared.js';
+/** The focus_debug_artifacts section the record lives in. */
+export const UNCLAIMED_MIGRATION_SECTION_KIND = 'unclaimed_migration';
+/** The line carrying the first-observed timestamp across re-records. */
+export const UNCLAIMED_SINCE_PREFIX = 'Unclaimed since: ';
+/**
+ * The line recording that this record has been PUT IN FRONT OF THE TEAM.
+ *
+ * WHY THE RECORD IS NOT ENOUGH ON ITS OWN. A record that nobody reads before
+ * the branch merges is a note written to an empty room: the file lands on
+ * integration holding a number no claim knows about, and the team that wrote it
+ * has finished. So an unnamed record is TEAM-ACTIONABLE WORK -- the completion
+ * path treats it the way it treats an outstanding merge-conflict resolution,
+ * and the team is not torn down before it has been handed the file.
+ *
+ * WHY IT IS MARKED, AND WHY THAT BOUNDS IT. The hold lasts exactly one coding
+ * turn: once the record has been composed into a spawn prompt, this line is
+ * written and the hold lifts, whether or not the team acted. A hold that
+ * persisted until the team complied would be a wedge -- the record clears only
+ * on a claim or a removal, and neither is something the daemon can force.
+ * Telling the team once is what was missing; compelling it is not this
+ * mechanism's business.
+ */
+export const UNCLAIMED_NAMED_PREFIX = 'Named to the team at: ';
+/** Render the human-facing record. */
+export function renderUnclaimedMigrationArtifact(args) {
+    const { focusName, branchName, files, since } = args;
+    const lines = [
+        `Focus: ${focusName}`,
+        `Branch: ${branchName}`,
+        `${UNCLAIMED_SINCE_PREFIX}${since}`,
+        '',
+        `${files.length} migration file${files.length === 1 ? '' : 's'} on this branch `
+            + 'were not claimed through Telora:',
+        '',
+        ...files.map((f) => `- ${f.ordinal}  ${f.path}`),
+        '',
+        'A migration number is claimed once, before the file is named, so two focuses',
+        'cut from one base cannot both take it. A file written without a claim is a',
+        'number nobody knows is taken: the next team to claim can be granted it.',
+        '',
+        'The team resolves this by claiming the number (telora_product_migration',
+        'action=claim) or removing the file. This record clears itself on the next',
+        'pass that sees either.',
+        // Carried across re-records so the one-turn hold is not re-armed by a
+        // commit; see UNCLAIMED_NAMED_PREFIX.
+        ...(args.namedAt ? ['', `${UNCLAIMED_NAMED_PREFIX}${args.namedAt}`] : []),
+    ];
+    return lines.join('\n');
+}
+/** When an existing record was last put in front of the team, or null. */
+export function parseUnclaimedNamedAt(content) {
+    if (!content)
+        return null;
+    for (const line of content.split('\n')) {
+        if (line.startsWith(UNCLAIMED_NAMED_PREFIX)) {
+            const value = line.slice(UNCLAIMED_NAMED_PREFIX.length).trim();
+            if (value)
+                return value;
+        }
+    }
+    return null;
+}
+/** Read the first-observed timestamp back out of an existing record. */
+export function parseUnclaimedSince(content) {
+    if (!content)
+        return null;
+    for (const line of content.split('\n')) {
+        if (line.startsWith(UNCLAIMED_SINCE_PREFIX)) {
+            const value = line.slice(UNCLAIMED_SINCE_PREFIX.length).trim();
+            if (value)
+                return value;
+        }
+    }
+    return null;
+}
+/** The record already on file for this focus, or undefined. */
+async function readExistingRecord(focusId) {
+    const result = await callApi('focus_debug_get', { focusId });
+    return (result?.sections ?? [])
+        .find((s) => s.sectionKind === UNCLAIMED_MIGRATION_SECTION_KIND)?.content;
+}
+/**
+ * Record that this focus's branch holds unclaimed migrations, carrying forward
+ * the first-observed timestamp when one is already on record.
+ */
+export async function recordUnclaimedMigrations(args) {
+    const { focusId, focusName, branchName, files, detectedAt } = args;
+    let existing;
+    try {
+        existing = await readExistingRecord(focusId);
+    }
+    catch {
+        // A failed read costs the ORIGINAL since-when, never the record itself.
+        existing = undefined;
+    }
+    // THE NAMED MARKER SURVIVES A RE-RECORD, BUT ONLY WHILE THE SET DOES NOT GROW.
+    // Re-recording happens on any tick where the branch moved, so resetting the
+    // marker each time would hold the team's teardown again after every commit --
+    // a fresh coding turn for a file it was told about already. A NEW unclaimed
+    // ordinal is new information, though, and earns its own turn, so the marker
+    // is dropped the moment the set grows.
+    const alreadyNamed = new Set(parseUnclaimedOrdinals(existing));
+    const grew = files.some((f) => !alreadyNamed.has(f.ordinal));
+    const namedAt = grew ? null : parseUnclaimedNamedAt(existing);
+    await callApi('focus_debug_set', {
+        focusId,
+        fields: {
+            sectionKind: UNCLAIMED_MIGRATION_SECTION_KIND,
+            content: renderUnclaimedMigrationArtifact({
+                focusName, branchName, files, since: parseUnclaimedSince(existing) ?? detectedAt, namedAt,
+            }),
+        },
+    });
+}
+/** Clear the record. Idempotent: deleting a section that is not there is a no-op. */
+export async function clearUnclaimedMigrations(focusId) {
+    await callApi('focus_debug_clear', {
+        focusId,
+        fields: { sectionKind: UNCLAIMED_MIGRATION_SECTION_KIND },
+    });
+}
+/**
+ * Read the record back, for the spawn prompt.
+ *
+ * Returns the rendered content, or null when the focus has no such record.
+ * The section is stored as prose because it is also a human-facing Debug-tab
+ * artifact; the prompt carries the same text rather than re-rendering it, so a
+ * team and a human read the identical account.
+ */
+export async function readUnclaimedMigrationRecord(focusId) {
+    try {
+        return await readUnclaimedMigrationRecordStrict(focusId);
+    }
+    catch {
+        // A spawn is never failed by a missing debug read: the team simply is not
+        // told this time, and the next pass re-records.
+        return null;
+    }
+}
+/**
+ * The same read, but a FAILURE THROWS.
+ *
+ * Two callers need the difference. A spawn must never be failed by a debug-tab
+ * read, so it takes the lenient form above. The completion path must not read
+ * a failed read as "there is nothing to tell" -- that is the destructive
+ * direction, the one that lets a team go with an unclaimed migration still on
+ * its branch -- so it takes this one and fails closed. Swallowing inside the
+ * query made both callers the same, and quietly defeated the second one's
+ * fail-closed handler: it could never see the failure it was written for.
+ */
+export async function readUnclaimedMigrationRecordStrict(focusId) {
+    const result = await callApi('focus_debug_get', { focusId });
+    const section = (result?.sections ?? [])
+        .find((s) => s.sectionKind === UNCLAIMED_MIGRATION_SECTION_KIND);
+    return section?.content ?? null;
+}
+/**
+ * The ordinals an existing record names.
+ *
+ * Read back so the lifecycle can keep an ordinal NAMED until the team resolves
+ * it. Without this the record clears the moment the branch merges -- its own
+ * unclaimed file then reads as inherited from integration, the detection goes
+ * quiet, and the record reports success for a problem that only moved.
+ *
+ * Parsed from the rendered lines rather than stored twice: one text is what a
+ * human reads on the Debug tab AND what the team is shown, and a second
+ * machine-readable copy is a second thing to keep in step.
+ */
+export function parseUnclaimedOrdinals(content) {
+    return parseUnclaimedEntries(content).map((e) => e.ordinal);
+}
+/**
+ * The record's entries, WITH their paths.
+ *
+ * The ordinals alone are not enough to re-render the record. When integration
+ * cannot be read, an ordinal the branch no longer shows can be neither proved
+ * merged nor proved removed -- so it must be carried forward verbatim, and
+ * carrying it forward needs the file it named. Reading it back from the record
+ * (rather than storing a second machine-readable copy) keeps one text as both
+ * what a human reads and what the lifecycle reasons over.
+ */
+export function parseUnclaimedEntries(content) {
+    if (!content)
+        return [];
+    const entries = [];
+    for (const line of content.split('\n')) {
+        const match = /^- (\S+)\s\s(.+)$/.exec(line);
+        if (match?.[1])
+            entries.push({ ordinal: match[1], path: (match[2] ?? '').trim() });
+    }
+    return entries;
+}
+/**
+ * Mark this focus's record as having been handed to the team.
+ *
+ * Called when the record is composed into a spawn prompt -- the moment the team
+ * is actually told. Writing it earlier (at detection) would lift the hold
+ * before anyone read it; writing it later (after the session ends) would hold a
+ * second turn for a file already named.
+ *
+ * Best effort by construction: a spawn is never failed by this write. The cost
+ * of losing it is one extra coding turn, and the cost of the whole mechanism
+ * failing is what it was before -- the team is still shown the record on every
+ * spawn while it stands, because the section renders on the record's existence,
+ * not on this marker.
+ */
+export async function markUnclaimedMigrationNamed(focusId, namedAt) {
+    try {
+        const existing = await readExistingRecord(focusId);
+        if (existing === undefined)
+            return;
+        if (parseUnclaimedNamedAt(existing) !== null)
+            return; // already named
+        await callApi('focus_debug_set', {
+            focusId,
+            fields: {
+                sectionKind: UNCLAIMED_MIGRATION_SECTION_KIND,
+                content: `${existing}\n${UNCLAIMED_NAMED_PREFIX}${namedAt}`,
+            },
+        });
+    }
+    catch {
+        // See above: never fails a spawn.
+    }
+}
+//# sourceMappingURL=focus-unclaimed-migration.js.map

package/dist/queries/focus-debug-artifacts/focus-unclaimed-migration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-unclaimed-migration.js","sourceRoot":"","sources":["../../../src/queries/focus-debug-artifacts/focus-unclaimed-migration.ts"],"names":[],"mappings":"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"}

package/dist/queries/focus-review/focus-branch-work-evidence.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Record WHICH of a focus's deliveries have commits on the focus branch
+ * (product_focuses.branch_work_delivery_ids), as proved by a
+ * `Telora-Delivery` trailer search in the focus's repository.
+ *
+ * NEVER MARKS ANYTHING REVIEWED, AND NEVER RELEASES ANYTHING. An id in this
+ * set makes a delivery work-bearing, and therefore holdable by the residue
+ * gate under the normal coverage rules. An id that is absent from it asserts
+ * nothing at all: the gate treats a stored reading as positive-only, because
+ * "the branch carries no commits for this delivery" is true of an INSTANT and
+ * this value is read minutes or hours later, by a runtime that cannot check.
+ *
+ * CALL ONLY WHEN THE BRANCH WAS ACTUALLY READ, and mean it -- the whole array
+ * replaces the stored one. An empty array is therefore a WITHDRAWAL of every
+ * hold the previous reading was carrying, which is the dangerous direction: a
+ * caller that could not look must call nothing at all, never this with `[]`.
+ * `resolvers/focus-review-coverage.ts` is the production caller and holds that
+ * precondition.
+ */
+export declare function setBranchWorkDeliveryIds(focusId: string, deliveryIds: readonly string[]): Promise<void>;
+//# sourceMappingURL=focus-branch-work-evidence.d.ts.map

package/dist/queries/focus-review/focus-branch-work-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-branch-work-evidence.d.ts","sourceRoot":"","sources":["../../../src/queries/focus-review/focus-branch-work-evidence.ts"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B,OAAO,CAAC,IAAI,CAAC,CAKf"}

package/dist/queries/focus-review/focus-branch-work-evidence.js

@@ -0,0 +1,59 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/review-coverage/review-coverage-seam.test.ts,
+//   packages/daemon/src/queries/focus-review/focus-branch-work-evidence.test.ts,
+//   packages/daemon/src/resolvers/focus-review-coverage.test.ts
+// PINNED-BY-END
+/**
+ * The branch committed-work evidence write.
+ *
+ * The delivery ROW cannot carry this fact. A fast-forward merge-back records
+ * no `merge_commit_sha`, and a cancelled delivery's commits sit on the focus
+ * branch with nothing on the row naming them -- so only a caller holding the
+ * repository can see that the work exists. The daemon is that caller; the
+ * product-api delivery-create residue gate, which must ENFORCE on the same
+ * fact, runs on an edge runtime with no repository at all.
+ *
+ * So the side that can see it writes it down, through the same
+ * `daemon_update_focus_status` seam the review-coverage watermark uses
+ * (`focus-review-watermark.ts`). Its own module for the same two reasons that
+ * one has: it is a distinct fact with a distinct fail-closed direction, and
+ * `queries/focuses/focuses.ts` sits at the file-size ceiling.
+ *
+ * ONE DIRECTION, AND THEREFORE ONE FUNCTION. The gate reads a stored reading
+ * POSITIVELY only (`supabase/functions/_shared/delivery-review-coverage.ts` ->
+ * `resolveBranchWorkEvidence`): ids add holds, their absence grants nothing.
+ * With nothing to take back there is nothing to retract, so this module has a
+ * write and no retraction -- a retraction is itself a write, and would be
+ * missing in exactly the failure (write channel down) it would exist for.
+ *
+ * History: docs/daemon/history-platform.md (queries/focus-review/focus-branch-work-evidence.ts).
+ *
+ * @module queries/focus-review/focus-branch-work-evidence
+ */
+import { callApi } from '../api-client/shared.js';
+/**
+ * Record WHICH of a focus's deliveries have commits on the focus branch
+ * (product_focuses.branch_work_delivery_ids), as proved by a
+ * `Telora-Delivery` trailer search in the focus's repository.
+ *
+ * NEVER MARKS ANYTHING REVIEWED, AND NEVER RELEASES ANYTHING. An id in this
+ * set makes a delivery work-bearing, and therefore holdable by the residue
+ * gate under the normal coverage rules. An id that is absent from it asserts
+ * nothing at all: the gate treats a stored reading as positive-only, because
+ * "the branch carries no commits for this delivery" is true of an INSTANT and
+ * this value is read minutes or hours later, by a runtime that cannot check.
+ *
+ * CALL ONLY WHEN THE BRANCH WAS ACTUALLY READ, and mean it -- the whole array
+ * replaces the stored one. An empty array is therefore a WITHDRAWAL of every
+ * hold the previous reading was carrying, which is the dangerous direction: a
+ * caller that could not look must call nothing at all, never this with `[]`.
+ * `resolvers/focus-review-coverage.ts` is the production caller and holds that
+ * precondition.
+ */
+export async function setBranchWorkDeliveryIds(focusId, deliveryIds) {
+    await callApi('daemon_update_focus_status', {
+        focusId,
+        fields: { branchWorkDeliveryIds: [...deliveryIds] },
+    });
+}
+//# sourceMappingURL=focus-branch-work-evidence.js.map

package/dist/queries/focus-review/focus-branch-work-evidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-branch-work-evidence.js","sourceRoot":"","sources":["../../../src/queries/focus-review/focus-branch-work-evidence.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,0FAA0F;AAC1F,iFAAiF;AACjF,gEAAgE;AAChE,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAElD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,OAAe,EACf,WAA8B;IAE9B,MAAM,OAAO,CAAC,4BAA4B,EAAE;QAC1C,OAAO;QACP,MAAM,EAAE,EAAE,qBAAqB,EAAE,CAAC,GAAG,WAAW,CAAC,EAAE;KACpD,CAAC,CAAC;AACL,CAAC"}