@indigoai-us/hq-cli 5.145.0 → 5.146.0

package/dist/lib/mesh/live/daemon/presence.d.ts

@@ -84,6 +84,13 @@ export interface PresenceClientOptions {
     onRefusal?: (refusal: PresenceRefusal | null) => void;
     now?: () => Date;
     env?: NodeJS.ProcessEnv;
+    /**
+     * Companies the daemon is working in. When the set changes, presence
+     * re-vends instead of waiting for credential expiry (at most once a minute).
+     * Undefined means a read failed — do not re-vend.
+     */
+    readPreferredCompanyUids?: () => string[] | undefined;
+    preferredRevendMinMs?: number;
 }
 /**
  * Full-jitter capped exponential backoff (1s base → 60s cap by default),
@@ -123,6 +130,9 @@ export declare class PresenceClient {
     /** Last refusal code we logged via onError (episode dedupe). */
     private loggedRefusalKey;
     private refusal;
+    private preferredHandle;
+    private preferredSnapshot;
+    private lastPreferredVendMs;
     private readonly mqttConnect;
     private readonly timers;
     private readonly random;
@@ -137,6 +147,11 @@ export declare class PresenceClient {
     getRefusal(): PresenceRefusal | null;
     /** Topics this client has published to (for doctor / tests). */
     getPublishedTopics(): readonly string[];
+    private preferredMinMs;
+    private notePreferredVend;
+    private clearPreferredWatch;
+    private armPreferredWatch;
+    private maybeRevendPreferred;
     private setState;
     start(): Promise<void>;
     /**

package/dist/lib/mesh/live/daemon/presence.js

@@ -12,7 +12,7 @@
  * - Server credential refusals use a long retry (default 10m ±20%)
  */
 import mqtt from "mqtt";
-import { CredentialVendError, CredentialRenewalManager, MQTT_KEEPALIVE_SECONDS, clampRetryDelayMs, defaultRefusedRetryMs, realTimerHost, refusedRetryDelayMs, scheduleBoundedTimeout, } from "./credentials.js";
+import { CredentialVendError, CredentialRenewalManager, MQTT_KEEPALIVE_SECONDS, PREFERRED_REVEND_MIN_MS, clampRetryDelayMs, defaultRefusedRetryMs, realTimerHost, refusedRetryDelayMs, scheduleBoundedTimeout, shouldRevendPreferredCompanies, } from "./credentials.js";
 import { presignIotWssUrl } from "./presign.js";
 /**
  * A connection that drops before this grace window after `connect` is treated
@@ -93,6 +93,9 @@ export class PresenceClient {
     /** Last refusal code we logged via onError (episode dedupe). */
     loggedRefusalKey = null;
     refusal = null;
+    preferredHandle = null;
+    preferredSnapshot = [];
+    lastPreferredVendMs = 0;
     mqttConnect;
     timers;
     random;
@@ -128,6 +131,67 @@ export class PresenceClient {
     getPublishedTopics() {
         return this.publishedTopics;
     }
+    preferredMinMs() {
+        return this.options.preferredRevendMinMs ?? PREFERRED_REVEND_MIN_MS;
+    }
+    notePreferredVend() {
+        const read = this.options.readPreferredCompanyUids;
+        if (!read)
+            return;
+        let next;
+        try {
+            next = read();
+        }
+        catch {
+            return;
+        }
+        if (!next)
+            return;
+        this.preferredSnapshot = next;
+        this.lastPreferredVendMs = this.timers.now();
+    }
+    clearPreferredWatch() {
+        if (this.preferredHandle) {
+            this.preferredHandle.clear();
+            this.preferredHandle = null;
+        }
+    }
+    armPreferredWatch() {
+        if (!this.options.readPreferredCompanyUids || this.stopped)
+            return;
+        this.clearPreferredWatch();
+        this.preferredHandle = scheduleBoundedTimeout(this.timers, () => {
+            this.preferredHandle = null;
+            if (this.stopped)
+                return;
+            this.maybeRevendPreferred();
+            this.armPreferredWatch();
+        }, this.preferredMinMs());
+    }
+    maybeRevendPreferred() {
+        const read = this.options.readPreferredCompanyUids;
+        if (!read || this.stopped || this.refusal)
+            return;
+        let next;
+        try {
+            next = read();
+        }
+        catch {
+            return;
+        }
+        if (!shouldRevendPreferredCompanies({
+            previous: this.preferredSnapshot,
+            next,
+            lastVendMs: this.lastPreferredVendMs,
+            nowMs: this.timers.now(),
+            minIntervalMs: this.preferredMinMs(),
+        })) {
+            return;
+        }
+        this.lastPreferredVendMs = this.timers.now();
+        this.preferredSnapshot = next;
+        this.renewal.renewNow();
+    }
     setState(state) {
         if (this.state === state)
             return;
@@ -149,6 +213,7 @@ export class PresenceClient {
         this.stopped = true;
         this.generation += 1;
         this.renewal.stop();
+        this.clearPreferredWatch();
         this.clearReconnect();
         this.clearStableTimer();
         this.connectedAtMs = null;
@@ -190,6 +255,7 @@ export class PresenceClient {
     }
     async onCredentialsRenewed(bundle) {
         this.bundle = bundle;
+        this.notePreferredVend();
         // Successful vend ends a refusal episode (renewal skips connectOnce's vend path).
         this.clearRefusal(true);
         if (this.stopped)
@@ -249,6 +315,8 @@ export class PresenceClient {
                 // Successful vend ends a refusal episode (even before MQTT connects).
                 this.clearRefusal(true);
                 this.renewal.schedule(this.bundle);
+                this.notePreferredVend();
+                this.armPreferredWatch();
             }
             const bundle = this.bundle;
             const url = presignIotWssUrl(bundle.credentials, bundle.iotEndpoint, bundle.region, this.now());

package/dist/lib/mesh/live/daemon/run.js

@@ -26,7 +26,7 @@ import { backfillHeldSessions, } from "../backfill-held.js";
 import { reconcileObservation } from "../../../work-context/reconcile.js";
 import { workMeshRoot, workMeshSpoolPath } from "../paths.js";
 import { createVaultBoardReader, refreshBoundSessionBoards, BOARD_REFRESH_INTERVAL_MS, } from "./board-refresh.js";
-import { createContract3Fetcher, createPersonalRealtimeFetcher, realTimerHost, } from "./credentials.js";
+import { createContract3Fetcher, createPersonalRealtimeFetcher, readPreferredCompanyUids, realTimerHost, } from "./credentials.js";
 import { appendDaemonLog, daemonLogLine, ensureDaemonLog } from "./log.js";
 import { acquirePidLock, defaultPidLockDeps, releasePidLock, } from "./pid-lock.js";
 import { daemonDir } from "./paths.js";
@@ -392,6 +392,7 @@ export async function runMeshDaemon(deps = {}) {
                     token: t,
                     baseUrl: resolveVaultApiBase(env),
                     env,
+                    readPreferredCompanyUids: () => readPreferredCompanyUids({ workContextRoot: ctxRoot }),
                 })();
             });
         const fetchCredentials = async () => {
@@ -418,6 +419,7 @@ export async function runMeshDaemon(deps = {}) {
                 }, now);
                 log(dir, `presence online companies=${companies.length}`);
             },
+            readPreferredCompanyUids: () => readPreferredCompanyUids({ workContextRoot: ctxRoot }),
             onRefusal: (refusal) => {
                 patchDaemonState(dir, {
                     presenceRefusal: refusal,

package/dist/lib/mesh/project-board.d.ts

@@ -1,4 +1,18 @@
 import { type MeshCompany, type MeshProjectRegistration, type MeshProjectRepo, type MeshProjectStoryInput, type MeshProjectView } from "./api.js";
+/**
+ * POST /v1/work-mesh/projects/{id}/register always binds the server-derived
+ * proj- thread (projectGenesisThreadId). It does not accept a client threadId.
+ * Close a thread only when this same ensure created it and register returned
+ * a different canonical id. An already-open thread stays open on a re-run.
+ * The Board view reads the registered thread.
+ */
+export declare function closeSupersededProjectThread(input: {
+    token: string;
+    companyUid: string;
+    openedThreadId: string;
+    canonicalThreadId: string;
+    created: boolean;
+}): Promise<void>;
 /**
  * Create a missing Board. Register returns 403 PROJECT_NOT_IN_COMPANY until
  * the genesis thread and the project view both exist, so the order is fixed:

package/dist/lib/mesh/project-board.js

@@ -1,4 +1,20 @@
-import { ensureProjectThread, getProjectView, putProjectView, registerMeshProject, } from "./api.js";
+import { appendThreadEvent, ensureProjectThread, getProjectView, putProjectView, registerMeshProject, } from "./api.js";
+/**
+ * POST /v1/work-mesh/projects/{id}/register always binds the server-derived
+ * proj- thread (projectGenesisThreadId). It does not accept a client threadId.
+ * Close a thread only when this same ensure created it and register returned
+ * a different canonical id. An already-open thread stays open on a re-run.
+ * The Board view reads the registered thread.
+ */
+export async function closeSupersededProjectThread(input) {
+    if (!input.created)
+        return;
+    if (!input.openedThreadId || input.openedThreadId === input.canonicalThreadId)
+        return;
+    await appendThreadEvent(input.token, input.companyUid, input.openedThreadId, "done", {
+        summary: "Superseded by the registered project thread.",
+    });
+}
 /**
  * Create a missing Board. Register returns 403 PROJECT_NOT_IN_COMPANY until
  * the genesis thread and the project view both exist, so the order is fixed:
@@ -18,6 +34,13 @@ export async function ensureProjectBoard(input) {
         repos: input.repos ?? [],
     });
     const registration = await registerMeshProject(input.token, input.company.companyUid, input.projectId);
+    await closeSupersededProjectThread({
+        token: input.token,
+        companyUid: input.company.companyUid,
+        openedThreadId: genesis.threadId,
+        canonicalThreadId: registration.threadId,
+        created: genesis.created,
+    });
     const view = await getProjectView(input.token, input.company.companyUid, input.projectId);
     if (view.projectId !== input.projectId || view.companyUid !== input.company.companyUid) {
         throw new Error(`Work mesh project board does not match ${input.company.companyUid}/${input.projectId}.`);

package/dist/lib/work-context/bind-best.d.ts

@@ -41,6 +41,8 @@ export declare function discoverProjects(input: {
     env?: NodeJS.ProcessEnv;
     home?: string;
 }): CatalogProject[];
+/** discoverProjects memoized by directory mtime. A cache hit does not rescan. */
+export declare function discoverProjectsCached(input: Parameters<typeof discoverProjects>[0], nowMs?: number): CatalogProject[];
 export declare function refineProjectBinding(input: {
     hint?: string;
     hqRoot?: string;

package/dist/lib/work-context/bind-best.js

@@ -188,11 +188,44 @@ export function discoverProjects(input) {
     }
     return [...map.values()];
 }
+const CATALOG_CACHE_TTL_MS = 5000;
+let catalogCache = null;
+function catalogStamp(input) {
+    const hqRoot = input.hqRoot?.trim();
+    const slug = input.companySlug?.trim();
+    const dirs = [
+        hqRoot && slug ? path.join(hqRoot, "companies", slug, "projects") : "",
+        hqRoot ? path.join(hqRoot, "personal", "projects") : "",
+        input.companyUid
+            ? path.join(meshCacheRoot(input.home ?? os.homedir(), input.env), "projects", input.companyUid)
+            : "",
+    ];
+    return dirs.map((dir) => {
+        if (!dir)
+            return "0";
+        try {
+            return String(fs.statSync(dir).mtimeMs);
+        }
+        catch {
+            return "0";
+        }
+    }).join("|");
+}
+/** discoverProjects memoized by directory mtime. A cache hit does not rescan. */
+export function discoverProjectsCached(input, nowMs = Date.now()) {
+    const key = `${input.hqRoot ?? ""}|${input.companySlug ?? ""}|${input.companyUid ?? ""}|${input.home ?? ""}|${catalogStamp(input)}`;
+    if (catalogCache && catalogCache.key === key && nowMs - catalogCache.at < CATALOG_CACHE_TTL_MS) {
+        return catalogCache.rows;
+    }
+    const rows = discoverProjects(input);
+    catalogCache = { key, at: nowMs, rows };
+    return rows;
+}
 export function refineProjectBinding(input) {
     const hint = input.hint?.trim();
     if (!hint)
         return { action: "keep" };
-    const catalog = discoverProjects(input);
+    const catalog = discoverProjectsCached(input, input.nowMs ?? Date.now());
     const exact = catalog.find((row) => row.projectId === hint);
     if (exact?.hasBoard) {
         return { action: "bind", projectId: hint, reason: "exact slug has a Board" };

package/dist/lib/work-context/bind-calling-session.d.ts

@@ -0,0 +1,26 @@
+/**
+ * US-040: when this process ensures a project, bind the calling session
+ * if it is still unresolved in the same company. Never move a session
+ * that is already on a different project.
+ */
+export interface CallingCompany {
+    companyUid: string;
+    companySlug: string;
+}
+export type BindCallingResult = {
+    bound: true;
+    sessionId: string;
+    projectId: string;
+} | {
+    bound: false;
+    reason: "no_session" | "no_state" | "company_mismatch" | "different_project" | "already_bound" | "not_unresolved";
+};
+export declare function bindCallingSession(input: {
+    root: string;
+    env?: NodeJS.ProcessEnv;
+    projectId: string;
+    company: CallingCompany;
+    now?: () => Date;
+}): BindCallingResult;
+export declare function formatSessionBoundLine(sessionId: string, projectId: string): string;
+//# sourceMappingURL=bind-calling-session.d.ts.map

package/dist/lib/work-context/bind-calling-session.js

@@ -0,0 +1,63 @@
+/**
+ * US-040: when this process ensures a project, bind the calling session
+ * if it is still unresolved in the same company. Never move a session
+ * that is already on a different project.
+ */
+import { sessionIdFromEnv } from "../mesh/live/session-identity.js";
+import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
+import { readSessionState, updateSessionState } from "./state.js";
+function sameCompany(state, company) {
+    if (state.companyUid && state.companyUid === company.companyUid)
+        return true;
+    if (state.companySlug &&
+        company.companySlug &&
+        state.companySlug.toLowerCase() === company.companySlug.toLowerCase()) {
+        return true;
+    }
+    return false;
+}
+export function bindCallingSession(input) {
+    const sessionId = sessionIdFromEnv(input.env ?? process.env);
+    if (!sessionId)
+        return { bound: false, reason: "no_session" };
+    const current = readSessionState(sessionId, input.root);
+    if (!current)
+        return { bound: false, reason: "no_state" };
+    if (!sameCompany(current, input.company))
+        return { bound: false, reason: "company_mismatch" };
+    if (current.projectId && current.projectId !== input.projectId) {
+        return { bound: false, reason: "different_project" };
+    }
+    if (current.projectId === input.projectId && (current.contextStatus === "bound" || current.contextStatus === "needs_task")) {
+        return { bound: false, reason: "already_bound" };
+    }
+    if (current.contextStatus !== "needs_project" && current.contextStatus !== "unresolved") {
+        return { bound: false, reason: "not_unresolved" };
+    }
+    const nowIso = (input.now ?? (() => new Date()))().toISOString();
+    const updated = updateSessionState(sessionId, input.root, (state) => {
+        if (!state)
+            return null;
+        if (state.projectId && state.projectId !== input.projectId)
+            return state;
+        return {
+            ...state,
+            contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+            contextStatus: state.taskId ? "bound" : "needs_task",
+            projectId: input.projectId,
+            projectGate: undefined,
+            projectCandidates: undefined,
+            projectHint: undefined,
+            projectBindReason: `bound by project ensure to ${input.projectId}`,
+            updatedAt: nowIso,
+        };
+    });
+    if (!updated || updated.projectId !== input.projectId) {
+        return { bound: false, reason: "different_project" };
+    }
+    return { bound: true, sessionId, projectId: input.projectId };
+}
+export function formatSessionBoundLine(sessionId, projectId) {
+    return `Work mesh: session ${sessionId} bound to project ${projectId}`;
+}
+//# sourceMappingURL=bind-calling-session.js.map

package/dist/lib/work-context/prd-sync.d.ts

@@ -0,0 +1,34 @@
+/**
+ * US-040: diff a bound project's prd.json and describe task_status events.
+ * Planning never touches the network. The snapshot is written only after
+ * the caller accepts the plan (commit), so a failed emit can retry.
+ */
+export interface PrdStatusEvent {
+    taskId: string;
+    status: "done" | "in_progress";
+}
+export interface PrdSnapshot {
+    stories: Record<string, {
+        passes: boolean;
+        status?: string;
+    }>;
+    seq: number;
+}
+export declare function prdSnapshotPath(sessionId: string, root: string): string;
+export declare function readPrdSnapshot(sessionId: string, root: string): PrdSnapshot | null;
+export declare function prdBelongsToProject(file: string, projectId: string, companySlug: string | undefined): boolean;
+export interface PrdSyncPlan {
+    changed: boolean;
+    skip?: "no_state" | "not_bound" | "different_project" | "unreadable";
+    events: PrdStatusEvent[];
+    /** Story most recently moved to in_progress, if any. */
+    taskId?: string;
+    seqStart: number;
+    commit: () => void;
+}
+export declare function planPrdSync(input: {
+    sessionId: string;
+    file: string;
+    root: string;
+}): PrdSyncPlan;
+//# sourceMappingURL=prd-sync.d.ts.map

package/dist/lib/work-context/prd-sync.js

@@ -0,0 +1,120 @@
+/**
+ * US-040: diff a bound project's prd.json and describe task_status events.
+ * Planning never touches the network. The snapshot is written only after
+ * the caller accepts the plan (commit), so a failed emit can retry.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readSessionState } from "./state.js";
+export function prdSnapshotPath(sessionId, root) {
+    return path.join(root, "sessions", `${sessionId}.prd-snapshot.json`);
+}
+export function readPrdSnapshot(sessionId, root) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(prdSnapshotPath(sessionId, root), "utf8"));
+        if (!parsed || typeof parsed !== "object" || !parsed.stories)
+            return null;
+        return { stories: parsed.stories, seq: typeof parsed.seq === "number" ? parsed.seq : 0 };
+    }
+    catch {
+        return null;
+    }
+}
+function writeSnapshot(sessionId, root, snapshot) {
+    const dest = prdSnapshotPath(sessionId, root);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, `${JSON.stringify(snapshot)}\n`, { mode: 0o600 });
+}
+export function prdBelongsToProject(file, projectId, companySlug) {
+    if (!companySlug)
+        return false;
+    const parts = path.resolve(file).split(path.sep);
+    if (parts[parts.length - 1] !== "prd.json")
+        return false;
+    const projectsAt = parts.lastIndexOf("projects");
+    return (projectsAt >= 2 &&
+        parts[projectsAt - 2] === "companies" &&
+        parts[projectsAt - 1] === companySlug &&
+        parts[projectsAt + 1] === projectId &&
+        parts.length === projectsAt + 3);
+}
+function storiesFromPrd(file) {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    const rows = Array.isArray(parsed.userStories) ? parsed.userStories
+        : Array.isArray(parsed.stories) ? parsed.stories
+            : [];
+    const out = [];
+    for (const row of rows) {
+        if (!row || typeof row !== "object")
+            continue;
+        const id = row.id;
+        if (typeof id !== "string" || !id.trim())
+            continue;
+        const status = row.status;
+        out.push({
+            id: id.trim(),
+            passes: row.passes === true,
+            ...(typeof status === "string" && status.trim() ? { status: status.trim() } : {}),
+        });
+    }
+    return out;
+}
+export function planPrdSync(input) {
+    const empty = (skip) => ({
+        changed: false,
+        skip,
+        events: [],
+        seqStart: 0,
+        commit: () => { },
+    });
+    let state;
+    try {
+        state = readSessionState(input.sessionId, input.root);
+    }
+    catch {
+        return empty("unreadable");
+    }
+    if (!state)
+        return empty("no_state");
+    if (!state.projectId || (state.contextStatus !== "bound" && state.contextStatus !== "needs_task")) {
+        return empty("not_bound");
+    }
+    if (!prdBelongsToProject(input.file, state.projectId, state.companySlug))
+        return empty("different_project");
+    let stories;
+    try {
+        stories = storiesFromPrd(input.file);
+    }
+    catch {
+        return empty("unreadable");
+    }
+    const previous = readPrdSnapshot(input.sessionId, input.root);
+    const before = previous?.stories ?? {};
+    const events = [];
+    let taskId;
+    const nextStories = {};
+    for (const story of stories) {
+        nextStories[story.id] = {
+            passes: story.passes,
+            ...(story.status ? { status: story.status } : {}),
+        };
+        const prior = previous ? before[story.id] : undefined;
+        if (story.passes && !prior?.passes) {
+            events.push({ taskId: story.id, status: "done" });
+            continue;
+        }
+        if (story.status === "in_progress" && prior?.status !== "in_progress") {
+            events.push({ taskId: story.id, status: "in_progress" });
+            taskId = story.id;
+        }
+    }
+    const snapshot = { stories: nextStories, seq: (previous?.seq ?? 0) + events.length };
+    return {
+        changed: events.length > 0,
+        events,
+        ...(taskId ? { taskId } : {}),
+        seqStart: previous?.seq ?? 0,
+        commit: () => writeSnapshot(input.sessionId, input.root, snapshot),
+    };
+}
+//# sourceMappingURL=prd-sync.js.map

package/dist/lib/work-context/prompt-rebind.d.ts

@@ -0,0 +1,21 @@
+/**
+ * US-040: UserPromptSubmit re-runs bind-best for a session still in
+ * needs_project. Catalog reads are cached. Failures stay local.
+ */
+export type PromptRebindResult = {
+    action: "bound" | "skipped" | "unchanged";
+    projectId?: string;
+    reason: string;
+};
+export declare function rebindNeedsProjectOnPrompt(input: {
+    sessionId: string;
+    root: string;
+    hqRoot?: string;
+    cwd?: string;
+    companySlug?: string;
+    companyUid?: string;
+    env?: NodeJS.ProcessEnv;
+    nowMs?: number;
+    now?: () => Date;
+}): PromptRebindResult;
+//# sourceMappingURL=prompt-rebind.d.ts.map

package/dist/lib/work-context/prompt-rebind.js

@@ -0,0 +1,76 @@
+/**
+ * US-040: UserPromptSubmit re-runs bind-best for a session still in
+ * needs_project. Catalog reads are cached. Failures stay local.
+ */
+import { projectIdFromCwd } from "./company.js";
+import { readMetaProjectTask } from "./project.js";
+import { refineProjectBinding } from "./bind-best.js";
+import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
+import { readSessionState, updateSessionState } from "./state.js";
+export function rebindNeedsProjectOnPrompt(input) {
+    let state;
+    try {
+        state = readSessionState(input.sessionId, input.root);
+    }
+    catch {
+        return { action: "skipped", reason: "state_unreadable" };
+    }
+    if (!state)
+        return { action: "skipped", reason: "no_state" };
+    if (state.contextStatus !== "needs_project") {
+        return { action: "skipped", reason: "not_needs_project" };
+    }
+    if (state.projectId)
+        return { action: "skipped", reason: "different_project" };
+    const env = input.env ?? process.env;
+    const hint = state.projectHint?.trim() ||
+        env.HQ_SPAWN_PROJECT?.trim() ||
+        readMetaProjectTask(input.sessionId, input.hqRoot).projectId ||
+        projectIdFromCwd(input.cwd, input.hqRoot) ||
+        undefined;
+    if (!hint)
+        return { action: "unchanged", reason: "no_hint" };
+    let refined;
+    try {
+        refined = refineProjectBinding({
+            hint,
+            hqRoot: input.hqRoot,
+            companySlug: input.companySlug ?? state.companySlug,
+            companyUid: input.companyUid ?? state.companyUid,
+            repoPath: input.cwd,
+            env,
+            nowMs: input.nowMs ?? Date.now(),
+        });
+    }
+    catch (err) {
+        return { action: "unchanged", reason: err instanceof Error ? err.message : "bind_failed" };
+    }
+    if (refined.action !== "bind" && refined.action !== "create") {
+        return { action: "unchanged", reason: refined.action === "ask" ? refined.reason : "no_match" };
+    }
+    const projectId = refined.projectId;
+    const reason = refined.reason;
+    const nowIso = (input.now ?? (() => new Date()))().toISOString();
+    const updated = updateSessionState(input.sessionId, input.root, (current) => {
+        if (!current || current.contextStatus !== "needs_project")
+            return current;
+        if (current.projectId && current.projectId !== projectId)
+            return current;
+        return {
+            ...current,
+            contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+            contextStatus: current.taskId ? "bound" : "needs_task",
+            projectId,
+            projectGate: undefined,
+            projectCandidates: undefined,
+            projectHint: undefined,
+            projectBindReason: reason,
+            updatedAt: nowIso,
+        };
+    });
+    if (!updated || updated.projectId !== projectId) {
+        return { action: "skipped", reason: "not_applied" };
+    }
+    return { action: "bound", projectId, reason };
+}
+//# sourceMappingURL=prompt-rebind.js.map

package/dist/lib/work-context/reconcile.d.ts

@@ -39,6 +39,8 @@ export interface ReconcileObservation {
     source?: "hooks" | "transcript";
     /** Optional turn signal for the 10-minute ask threshold (US-007B). */
     hasTurn?: boolean;
+    /** Hook name when the caller is a prompt submit. Session start omits this. */
+    hookEvent?: string;
     toolWrites?: number;
     /** Prohibited content may appear on the wire-in observation; must be stripped. */
     prompt?: unknown;