@indigoai-us/hq-cli 5.108.1 → 5.108.2

package/dist/lib/work-context/company.js

@@ -0,0 +1,274 @@
+/**
+ * Company precedence for work-context reconcile (US-007A).
+ *
+ * Order:
+ *   1. trusted explicit (HQ_SPAWN_COMPANY env or observation.trustedContext/explicit)
+ *   2. existing authoritative session scope
+ *   3. session meta.yaml company_slug (/startwork)
+ *   4. agent-box identity file (HQ_AGENT_IDENTITY_FILE → companyUid; source
+ *      trusted_explicit — never "default company mode"; below HQ_SPAWN_COMPANY,
+ *      above device default)
+ *   5. enabled device default
+ *   6. exactly one deterministic mapping (cwd under companies/{slug}/ or repo remote)
+ *
+ * Prompt-text matching is never used.
+ * Device default + conflicting deterministic evidence → company_conflict.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getDefaultCompany } from "./config.js";
+import { authoritativeCompanyFromState, readSessionState, } from "./state.js";
+/** Pointer to the US-017B correction client (never auto-switches). */
+export const COMPANY_CORRECTION_PATH_PREFIX = "hq mesh context correct --session";
+export function companyCorrectionPath(sessionId) {
+    return `${COMPANY_CORRECTION_PATH_PREFIX} ${sessionId}`;
+}
+const SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/** Env naming the on-box identity.json (fleet agent boxes). */
+export const HQ_AGENT_IDENTITY_FILE_ENV = "HQ_AGENT_IDENTITY_FILE";
+function normalizeSlug(value) {
+    if (!value)
+        return undefined;
+    const s = value.trim();
+    if (!s || !SLUG_RE.test(s))
+        return undefined;
+    return s;
+}
+/**
+ * Read `companyUid` from the agent identity file when
+ * `HQ_AGENT_IDENTITY_FILE` is set. Missing/unreadable/malformed → undefined
+ * (never throws; never logs file contents).
+ */
+export function readAgentIdentityCompanyUid(env = process.env) {
+    const file = env[HQ_AGENT_IDENTITY_FILE_ENV]?.trim();
+    if (!file)
+        return undefined;
+    try {
+        if (!fs.existsSync(file))
+            return undefined;
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        const uid = raw.companyUid;
+        return typeof uid === "string" && uid.trim().length > 0
+            ? uid.trim()
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Compare companies: UIDs when both sides have them; otherwise normalized
+ * slugs when both have slugs. Never treat uid+slug vs slug-only as a
+ * conflict when the slugs match (verified scope under companies/{slug}/).
+ */
+export function sameCompany(a, b) {
+    const uidA = a.uid?.trim();
+    const uidB = b.uid?.trim();
+    if (uidA && uidB)
+        return uidA === uidB;
+    const slugA = a.slug?.trim().toLowerCase();
+    const slugB = b.slug?.trim().toLowerCase();
+    if (slugA && slugB)
+        return slugA === slugB;
+    return false;
+}
+/**
+ * Extract company slug from a cwd path containing `companies/{slug}/`.
+ */
+export function companySlugFromCwd(cwd, hqRoot) {
+    if (!cwd)
+        return undefined;
+    const normalized = path.resolve(cwd);
+    const parts = normalized.split(path.sep);
+    const idx = parts.lastIndexOf("companies");
+    if (idx >= 0 && idx + 1 < parts.length) {
+        const slug = normalizeSlug(parts[idx + 1]);
+        if (slug)
+            return slug;
+    }
+    if (hqRoot) {
+        const root = path.resolve(hqRoot);
+        const rel = path.relative(root, normalized);
+        if (!rel.startsWith("..") && !path.isAbsolute(rel)) {
+            const segs = rel.split(path.sep);
+            if (segs[0] === "companies" && segs[1]) {
+                return normalizeSlug(segs[1]);
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract project id from cwd under `companies/{slug}/projects/{project}/`
+ * (US-007B deterministic mapping). Never invents a project.
+ */
+export function projectIdFromCwd(cwd, hqRoot) {
+    if (!cwd)
+        return undefined;
+    const normalized = path.resolve(cwd);
+    const parts = normalized.split(path.sep);
+    const idx = parts.lastIndexOf("companies");
+    if (idx >= 0 &&
+        parts[idx + 2] === "projects" &&
+        typeof parts[idx + 3] === "string" &&
+        parts[idx + 3].length > 0) {
+        const project = normalizeSlug(parts[idx + 3]);
+        if (project)
+            return project;
+    }
+    if (hqRoot) {
+        const root = path.resolve(hqRoot);
+        const rel = path.relative(root, normalized);
+        if (!rel.startsWith("..") && !path.isAbsolute(rel)) {
+            const segs = rel.split(path.sep);
+            if (segs[0] === "companies" && segs[2] === "projects" && segs[3]) {
+                return normalizeSlug(segs[3]);
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Read company_slug from workspace/sessions/<sid>/meta.yaml (best-effort, no yaml dep).
+ */
+export function readMetaCompanySlug(sessionId, hqRoot) {
+    if (!hqRoot || !sessionId)
+        return undefined;
+    const metaPath = path.join(hqRoot, "workspace", "sessions", sessionId, "meta.yaml");
+    if (!fs.existsSync(metaPath))
+        return undefined;
+    try {
+        const text = fs.readFileSync(metaPath, "utf8");
+        // Minimal line parse: company_slug: value  (no prompt-text matching)
+        for (const line of text.split(/\r?\n/)) {
+            const m = /^\s*company_slug\s*:\s*["']?([A-Za-z0-9._-]+)["']?\s*$/.exec(line);
+            if (m?.[1])
+                return normalizeSlug(m[1]);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Deterministic mapping: exactly one of cwd companies/{slug} or remote owner.
+ * Multiple distinct signals that disagree → no deterministic mapping (needs_company
+ * unless a higher-precedence source exists). Matching signals collapse to one.
+ */
+export function resolveDeterministicCompany(input) {
+    const fromCwd = companySlugFromCwd(input.cwd, input.hqRoot);
+    const fromRemote = normalizeSlug(input.remoteOwnerSlug ?? undefined);
+    if (fromCwd && fromRemote && fromCwd.toLowerCase() !== fromRemote.toLowerCase()) {
+        // Ambiguous deterministic evidence — do not guess.
+        return null;
+    }
+    if (fromCwd) {
+        return { slug: fromCwd, source: "deterministic_cwd" };
+    }
+    if (fromRemote) {
+        return { slug: fromRemote, source: "deterministic_remote" };
+    }
+    return null;
+}
+export function resolveCompany(input) {
+    const env = input.env ?? process.env;
+    // 1. Trusted explicit: HQ_SPAWN_COMPANY or observation trusted/explicit.
+    const spawn = normalizeSlug(env.HQ_SPAWN_COMPANY);
+    const trustedSlug = normalizeSlug(input.trusted?.companySlug);
+    const trustedUid = input.trusted?.companyUid?.trim() || undefined;
+    if (spawn || trustedSlug || trustedUid) {
+        return {
+            status: "resolved",
+            company: {
+                slug: spawn ?? trustedSlug,
+                uid: trustedUid,
+                source: "trusted_explicit",
+            },
+        };
+    }
+    // 2. Existing authoritative session scope.
+    const state = input.existingState !== undefined
+        ? input.existingState
+        : readSessionState(input.sessionId, input.root);
+    const prior = authoritativeCompanyFromState(state);
+    if (prior) {
+        const scoped = {
+            slug: prior.slug,
+            uid: prior.uid,
+            source: "existing_scope",
+        };
+        // After a binding exists, a suspected other-company mismatch cannot
+        // auto-switch — return company_conflict with the US-017B correction path.
+        const hadBinding = Boolean(state &&
+            (state.contextStatus === "bound" ||
+                state.contextStatus === "needs_task" ||
+                state.contextStatus === "needs_project") &&
+            (state.projectId || state.bindingEpisodeId));
+        if (hadBinding) {
+            const deterministic = resolveDeterministicCompany({
+                cwd: input.cwd,
+                hqRoot: input.hqRoot,
+                remoteOwnerSlug: input.remoteOwnerSlug,
+            });
+            if (deterministic && !sameCompany(scoped, deterministic)) {
+                return {
+                    status: "company_conflict",
+                    defaultCompany: scoped,
+                    evidenceCompany: deterministic,
+                    afterBinding: true,
+                    correctionPath: companyCorrectionPath(input.sessionId),
+                };
+            }
+        }
+        return { status: "resolved", company: scoped };
+    }
+    // 3. session meta.yaml company_slug
+    const metaSlug = input.metaCompanySlug !== undefined
+        ? normalizeSlug(input.metaCompanySlug)
+        : readMetaCompanySlug(input.sessionId, input.hqRoot);
+    if (metaSlug) {
+        return {
+            status: "resolved",
+            company: { slug: metaSlug, source: "session_meta" },
+        };
+    }
+    // 4. Agent-box identity file (HQ_AGENT_IDENTITY_FILE). Prefer as the
+    // device-default role with source trusted_explicit — never device_default /
+    // "default company mode". Below HQ_SPAWN_COMPANY; above device default.
+    const identityUid = readAgentIdentityCompanyUid(env);
+    if (identityUid) {
+        return {
+            status: "resolved",
+            company: { uid: identityUid, source: "trusted_explicit" },
+        };
+    }
+    // 5 + 6. Device default vs deterministic evidence.
+    const deviceDefault = getDefaultCompany({ root: input.root });
+    const deterministic = resolveDeterministicCompany({
+        cwd: input.cwd,
+        hqRoot: input.hqRoot,
+        remoteOwnerSlug: input.remoteOwnerSlug,
+    });
+    if (deviceDefault?.enabled && deviceDefault.slug) {
+        const def = {
+            slug: deviceDefault.slug,
+            uid: deviceDefault.uid,
+            source: "device_default",
+        };
+        if (deterministic &&
+            !sameCompany(def, deterministic)) {
+            return {
+                status: "company_conflict",
+                defaultCompany: def,
+                evidenceCompany: deterministic,
+            };
+        }
+        return { status: "resolved", company: def };
+    }
+    if (deterministic) {
+        return { status: "resolved", company: deterministic };
+    }
+    return { status: "needs_company" };
+}
+//# sourceMappingURL=company.js.map

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

@@ -0,0 +1,59 @@
+/**
+ * Device-local default company preference (~/.hq/work-context/config.json).
+ * Preference only — never authority. activeCompany is never treated as default.
+ * Default-company mode ships dark until migrationCapability (US-017A).
+ */
+import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
+export declare const DEVICE_CONFIG_SCHEMA_VERSION: 1;
+export interface DeviceDefaultCompany {
+    slug: string;
+    uid?: string;
+    enabled: boolean;
+}
+/** Last probe of GET /v1/work-mesh/capabilities across memberships (US-017B). */
+export interface MigrationCapabilitySnapshot {
+    unlocked: boolean;
+    offline: boolean;
+    checkedAt: string;
+    companies: Array<{
+        companyUid: string;
+        migration: boolean;
+    }>;
+}
+export interface WorkContextDeviceConfig {
+    schemaVersion: typeof DEVICE_CONFIG_SCHEMA_VERSION;
+    /** Explicit device default. Never copied from activeCompany. */
+    defaultCompany?: DeviceDefaultCompany | null;
+    /** Last-known migration capability across memberships (doctor reports this). */
+    migrationCapability?: MigrationCapabilitySnapshot | null;
+    updatedAt: string;
+}
+/** true / { uid } = member; false = not a member. */
+export type MembershipValidationResult = boolean | {
+    uid: string;
+};
+export interface DeviceConfigDeps {
+    root: string;
+    /** When true, server advertises migrationCapability (unlocks set). */
+    migrationCapability?: boolean;
+    /**
+     * Current-membership check for set <slug>. Required for a successful set —
+     * when omitted, set rejects with DEFAULT_COMPANY_UNAVAILABLE (never assume member).
+     * Injectable for tests.
+     */
+    validateMembership?: (slug: string) => Promise<MembershipValidationResult> | MembershipValidationResult;
+    now?: () => Date;
+}
+export declare function readDeviceConfig(deps: Pick<DeviceConfigDeps, "root">): WorkContextDeviceConfig;
+export declare function getDefaultCompany(deps: Pick<DeviceConfigDeps, "root">): DeviceDefaultCompany | null;
+export declare function setDefaultCompany(slug: string, deps: DeviceConfigDeps & {
+    allowWithoutMigration?: boolean;
+}): Promise<WorkContextDeviceConfig>;
+export declare function clearDefaultCompany(deps: DeviceConfigDeps): WorkContextDeviceConfig;
+/** Persist the last memberships-wide migration capability probe (US-017B). */
+export declare function recordMigrationCapabilitySnapshot(snapshot: MigrationCapabilitySnapshot, deps: Pick<DeviceConfigDeps, "root" | "now">): WorkContextDeviceConfig;
+/** Convenience: build deps from HOME / injectable root. */
+export declare function deviceConfigDepsFromHome(home?: string, extras?: Partial<DeviceConfigDeps>): DeviceConfigDeps;
+/** Re-export for callers that stamp contractVersion on related state. */
+export { WORK_CONTEXT_CONTRACT_VERSION };
+//# sourceMappingURL=config.d.ts.map

package/dist/lib/work-context/config.js

@@ -0,0 +1,172 @@
+/**
+ * Device-local default company preference (~/.hq/work-context/config.json).
+ * Preference only — never authority. activeCompany is never treated as default.
+ * Default-company mode ships dark until migrationCapability (US-017A).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { atomicWriteJson, ensureOwnerDir, resolveRealTarget } from "./atomic.js";
+import { DefaultCompanyLockedError, DefaultCompanyUnavailableError, UnsafeConfigPathError, WorkContextError, } from "./errors.js";
+import { workContextConfigPath, workContextRoot } from "./paths.js";
+import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
+export const DEVICE_CONFIG_SCHEMA_VERSION = 1;
+function emptyConfig(now) {
+    return {
+        schemaVersion: DEVICE_CONFIG_SCHEMA_VERSION,
+        defaultCompany: null,
+        migrationCapability: null,
+        updatedAt: now().toISOString(),
+    };
+}
+function assertSafeConfigPath(configPath) {
+    const dir = path.dirname(configPath);
+    try {
+        if (fs.existsSync(dir)) {
+            const lst = fs.lstatSync(dir);
+            if (lst.isSymbolicLink()) {
+                throw new UnsafeConfigPathError(`Config directory is a symlink: ${dir}`);
+            }
+        }
+        if (fs.existsSync(configPath)) {
+            const lst = fs.lstatSync(configPath);
+            if (lst.isSymbolicLink()) {
+                throw new UnsafeConfigPathError(`Config file is a symlink: ${configPath}`);
+            }
+            const mode = lst.mode & 0o777;
+            // Warn-level only for world-writable; refuse group/other write bits on read for safety.
+            if (mode & 0o022) {
+                throw new UnsafeConfigPathError(`Config file has unsafe permissions ${mode.toString(8)} (expected owner-only)`);
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof UnsafeConfigPathError)
+            throw err;
+    }
+}
+export function readDeviceConfig(deps) {
+    const configPath = workContextConfigPath(deps.root);
+    assertSafeConfigPath(configPath);
+    if (!fs.existsSync(configPath)) {
+        return emptyConfig(() => new Date(0));
+    }
+    try {
+        const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        if (raw.schemaVersion !== DEVICE_CONFIG_SCHEMA_VERSION) {
+            throw new WorkContextError("ConfigCorruptionError", `Unsupported config schemaVersion ${String(raw.schemaVersion)}`);
+        }
+        // Never treat a stray activeCompany field as the default.
+        const cleaned = {
+            schemaVersion: DEVICE_CONFIG_SCHEMA_VERSION,
+            defaultCompany: raw.defaultCompany ?? null,
+            migrationCapability: raw.migrationCapability ?? null,
+            updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : new Date(0).toISOString(),
+        };
+        return cleaned;
+    }
+    catch (err) {
+        if (err instanceof WorkContextError)
+            throw err;
+        throw new WorkContextError("ConfigCorruptionError", `Invalid work-context config: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function writeDeviceConfig(deps, config) {
+    ensureOwnerDir(deps.root);
+    const configPath = resolveRealTarget(workContextConfigPath(deps.root));
+    assertSafeConfigPath(configPath);
+    atomicWriteJson(configPath, config);
+}
+export function getDefaultCompany(deps) {
+    const cfg = readDeviceConfig(deps);
+    const d = cfg.defaultCompany;
+    if (!d || !d.enabled || !d.slug?.trim())
+        return null;
+    return d;
+}
+export async function setDefaultCompany(slug, deps) {
+    const trimmed = slug.trim();
+    if (!trimmed || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(trimmed)) {
+        throw new WorkContextError("InvalidCompanySlug", `Invalid company slug: ${slug}`);
+    }
+    if (!deps.migrationCapability && !deps.allowWithoutMigration) {
+        throw new DefaultCompanyLockedError();
+    }
+    if (!deps.validateMembership) {
+        throw new DefaultCompanyUnavailableError(`Cannot verify membership for company "${trimmed}" (no membership validator)`);
+    }
+    let resolvedUid;
+    let result;
+    try {
+        result = await deps.validateMembership(trimmed);
+    }
+    catch (err) {
+        if (err instanceof DefaultCompanyUnavailableError)
+            throw err;
+        throw new DefaultCompanyUnavailableError(`Cannot verify membership for company "${trimmed}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (result === false) {
+        throw new DefaultCompanyUnavailableError(`Not a current member of company "${trimmed}"`);
+    }
+    if (result && typeof result === "object" && typeof result.uid === "string") {
+        resolvedUid = result.uid.trim() || undefined;
+    }
+    const now = deps.now ?? (() => new Date());
+    const prior = readDeviceConfig(deps);
+    const defaultCompany = {
+        slug: trimmed,
+        enabled: true,
+    };
+    if (resolvedUid)
+        defaultCompany.uid = resolvedUid;
+    const next = {
+        schemaVersion: DEVICE_CONFIG_SCHEMA_VERSION,
+        defaultCompany,
+        migrationCapability: prior.migrationCapability ?? null,
+        updatedAt: now().toISOString(),
+    };
+    writeDeviceConfig(deps, next);
+    return next;
+}
+export function clearDefaultCompany(deps) {
+    const now = deps.now ?? (() => new Date());
+    const prior = readDeviceConfig(deps);
+    const next = {
+        schemaVersion: DEVICE_CONFIG_SCHEMA_VERSION,
+        defaultCompany: null,
+        migrationCapability: prior.migrationCapability ?? null,
+        updatedAt: now().toISOString(),
+    };
+    writeDeviceConfig(deps, next);
+    return next;
+}
+/** Persist the last memberships-wide migration capability probe (US-017B). */
+export function recordMigrationCapabilitySnapshot(snapshot, deps) {
+    const prior = readDeviceConfig(deps);
+    const now = deps.now ?? (() => new Date());
+    const next = {
+        schemaVersion: DEVICE_CONFIG_SCHEMA_VERSION,
+        defaultCompany: prior.defaultCompany ?? null,
+        migrationCapability: {
+            unlocked: snapshot.unlocked,
+            offline: snapshot.offline,
+            checkedAt: snapshot.checkedAt,
+            companies: snapshot.companies.map((c) => ({
+                companyUid: c.companyUid,
+                migration: c.migration,
+            })),
+        },
+        updatedAt: now().toISOString(),
+    };
+    writeDeviceConfig({ root: deps.root }, next);
+    return next;
+}
+/** Convenience: build deps from HOME / injectable root. */
+export function deviceConfigDepsFromHome(home, extras = {}) {
+    return {
+        root: extras.root ?? workContextRoot(home),
+        ...extras,
+    };
+}
+/** Re-export for callers that stamp contractVersion on related state. */
+export { WORK_CONTEXT_CONTRACT_VERSION };
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,81 @@
+/**
+ * Work Context reconciliation contract (US-001A recreation for work-mesh-live).
+ *
+ * Recreated 2026-09-03 from
+ * companies/indigo/projects/work-context-resolver/architectural-decisions.md
+ * because feature/work-context-resolver-cli was not on origin. When Stefan's
+ * package lands, reconcile differences in the Work Mesh Live contract changelog.
+ *
+ * Shared domain model with docs/work-mesh-live-contract.md (hq-pro):
+ * Project, Task (taskId canonical, storyId ingress alias), Session, Work Binding,
+ * and the classification states below.
+ */
+export declare const WORK_CONTEXT_CONTRACT_VERSION: 1;
+/** Classification: where the Session belongs. */
+export type ClassificationState = "unresolved" | "needs_company" | "company_conflict" | "needs_project" | "needs_task" | "bound" | "untracked" | "migration_pending";
+/** Delivery: durable operation delivery / acknowledgement only. */
+export type DeliveryState = "clean" | "queued" | "acked" | "quarantined";
+/** Lifecycle: whether the Session may produce ordinary work events. */
+export type LifecycleState = "open" | "terminal";
+/** ContextResult kind vocabulary from US-001A. */
+export type ContextResultKind = "bound" | "needs_company" | "company_conflict" | "needs_project" | "needs_task" | "queued" | "untracked" | "migration_pending" | "incompatible" | "error";
+export declare const CLASSIFICATION_STATES: readonly ClassificationState[];
+export declare const CONTEXT_RESULT_KINDS: readonly ContextResultKind[];
+/** Local-only classification: no tenant read or write. */
+export declare const LOCAL_ONLY_CLASSIFICATION: ReadonlySet<ClassificationState>;
+export interface SessionIdentity {
+    sessionId: string;
+    providerSessionId?: string;
+    harness?: string;
+    adapterVersion?: string;
+    runtimeVersion?: string;
+}
+export interface TrustedExplicitContext {
+    companyUid?: string;
+    projectId?: string;
+    /** Canonical. Prefer over storyId. */
+    taskId?: string;
+    /** Ingress alias; normalize to taskId. */
+    storyId?: string;
+}
+export interface SessionObservation {
+    contractVersion: typeof WORK_CONTEXT_CONTRACT_VERSION;
+    identity: SessionIdentity;
+    explicit?: TrustedExplicitContext;
+    clientOperationId: string;
+    /** User-origin only; model/agent origins for untracked are rejected. */
+    untrackedOrigin?: "user";
+}
+export interface ContextResult {
+    contractVersion: typeof WORK_CONTEXT_CONTRACT_VERSION;
+    kind: ContextResultKind;
+    classification: ClassificationState;
+    delivery: DeliveryState;
+    lifecycle: LifecycleState;
+    sessionId: string;
+    companyUid?: string;
+    projectId?: string;
+    taskId?: string;
+    bindingEpisodeId?: string;
+    clientOperationId: string;
+    errorCode?: string;
+}
+export type NormalizeTaskIdResult = {
+    ok: true;
+    taskId: string;
+} | {
+    ok: false;
+    code: "TASK_ALIAS_CONFLICT" | "TASK_ID_MISSING";
+};
+/**
+ * Normalize taskId / storyId ingress. taskId is canonical; storyId is alias.
+ * Conflicting dual aliases are rejected.
+ */
+export declare function normalizeTaskId(input: {
+    taskId?: string;
+    storyId?: string;
+}): NormalizeTaskIdResult;
+export declare function isLocalOnlyClassification(state: ClassificationState): boolean;
+/** Content classes prohibited in durable work-context state. */
+export declare const WORK_CONTEXT_PROHIBITED_CONTENT_CLASSES: readonly ["prompts", "model_output", "transcripts", "message_bodies", "tokens", "credentials"];
+//# sourceMappingURL=contract.d.ts.map

package/dist/lib/work-context/contract.js

@@ -0,0 +1,65 @@
+/**
+ * Work Context reconciliation contract (US-001A recreation for work-mesh-live).
+ *
+ * Recreated 2026-09-03 from
+ * companies/indigo/projects/work-context-resolver/architectural-decisions.md
+ * because feature/work-context-resolver-cli was not on origin. When Stefan's
+ * package lands, reconcile differences in the Work Mesh Live contract changelog.
+ *
+ * Shared domain model with docs/work-mesh-live-contract.md (hq-pro):
+ * Project, Task (taskId canonical, storyId ingress alias), Session, Work Binding,
+ * and the classification states below.
+ */
+export const WORK_CONTEXT_CONTRACT_VERSION = 1;
+export const CLASSIFICATION_STATES = [
+    "unresolved",
+    "needs_company",
+    "company_conflict",
+    "needs_project",
+    "needs_task",
+    "bound",
+    "untracked",
+    "migration_pending",
+];
+export const CONTEXT_RESULT_KINDS = [
+    "bound",
+    "needs_company",
+    "company_conflict",
+    "needs_project",
+    "needs_task",
+    "queued",
+    "untracked",
+    "migration_pending",
+    "incompatible",
+    "error",
+];
+/** Local-only classification: no tenant read or write. */
+export const LOCAL_ONLY_CLASSIFICATION = new Set(["needs_company", "company_conflict", "untracked"]);
+/**
+ * Normalize taskId / storyId ingress. taskId is canonical; storyId is alias.
+ * Conflicting dual aliases are rejected.
+ */
+export function normalizeTaskId(input) {
+    const taskId = input.taskId?.trim() || undefined;
+    const storyId = input.storyId?.trim() || undefined;
+    if (taskId && storyId && taskId !== storyId) {
+        return { ok: false, code: "TASK_ALIAS_CONFLICT" };
+    }
+    const canonical = taskId ?? storyId;
+    if (!canonical)
+        return { ok: false, code: "TASK_ID_MISSING" };
+    return { ok: true, taskId: canonical };
+}
+export function isLocalOnlyClassification(state) {
+    return LOCAL_ONLY_CLASSIFICATION.has(state);
+}
+/** Content classes prohibited in durable work-context state. */
+export const WORK_CONTEXT_PROHIBITED_CONTENT_CLASSES = [
+    "prompts",
+    "model_output",
+    "transcripts",
+    "message_bodies",
+    "tokens",
+    "credentials",
+];
+//# sourceMappingURL=contract.js.map

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

@@ -0,0 +1,27 @@
+/**
+ * Typed Work Context errors (US-007A / resolver error map).
+ */
+export declare class WorkContextError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class NotTrackingError extends WorkContextError {
+    constructor(message: string, code?: string);
+}
+export declare class DefaultCompanyLockedError extends WorkContextError {
+    constructor(message?: string);
+}
+export declare class DefaultCompanyUnavailableError extends WorkContextError {
+    constructor(message?: string);
+}
+export declare class InvalidDecisionOriginError extends WorkContextError {
+    constructor(message?: string);
+}
+export declare class UnsafeConfigPathError extends WorkContextError {
+    constructor(message: string);
+}
+/** Exit codes for `hq mesh context reconcile` machine mode. */
+export declare const EXIT_OK = 0;
+export declare const EXIT_INVALID_IDENTITY = 2;
+export declare const EXIT_NOT_TRACKING = 3;
+//# sourceMappingURL=errors.d.ts.map