@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/commands/core-delegate-w1b.js

@@ -0,0 +1,1219 @@
+/** Native implementations of the second Wave 1 delegate command family. */
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { serializeJqJson } from "../lib/core-utils/jq-json-serializer.js";
+import { matchingSecretPatterns } from "../lib/core-utils/secret-patterns.js";
+import { describeCoreCommand } from "./core-command-catalog.js";
+import { commandExists, isRecord, jsonAt, jqFallback, jqRawPath, jqRawPaths, moveFile, readJsonFile, subprocess, writeJsonAtomically, } from "./core-delegate.js";
+import { resolveLiveRoot } from "../utils/hq-roots.js";
+import { ACL_SOURCE_DISPLAY_LABELS } from "../utils/files-browse-acl.js";
+import { runBundledScript } from "../utils/run-bundled-script.js";
+const FLAG = "core-native-delegate";
+const ASSETS = {
+    bundle: "core/scripts/hq-delegate-bundle.sh",
+    grant: "core/scripts/hq-delegate-grant.sh",
+    publish: "core/scripts/hq-delegate-publish.sh",
+    send: "core/scripts/hq-delegate-send.sh",
+    verify: "core/scripts/hq-delegate-verify.sh",
+};
+const DESCRIPTIONS = {
+    bundle: "Build a portable delegation bundle",
+    grant: "Grant and verify delegation vault access",
+    publish: "Publish canonical delegation files",
+    send: "Generate or send the delegation pickup prompt",
+    verify: "Probe delegation access and publish the handoff",
+};
+const USAGE = {
+    bundle: "hq-delegate-bundle.sh — freeze a project into a portable delegation bundle.\n\nUsage:\n  core/scripts/hq-delegate-bundle.sh build \\\n    --company <slug> --project <name> --to <principal> \\\n    [--to-kind person|agent] [--to-name <display name>] \\\n    [--mode transfer|share] [--dry-run]\n\n--dry-run prints the manifest JSON to stdout and writes nothing.\n\nWrites workspace/delegations/<delegationId>/{manifest.json,BRIEF.md} and\n",
+    grant: "hq-delegate-grant.sh — materialize a delegation's dossier in the vault and\nwrite the ACL grants its manifest declares, verifying each one landed.\n\nUsage:\n  core/scripts/hq-delegate-grant.sh --manifest <path> [--yes]\n\nWithout --yes: prints the full grant plan (prefix, principal, permission —\nthe write grant is a privilege escalation and needs explicit confirmation)\nand exits 2 without mutating anything. The caller (the /delegate skill)\nconfirms with the user, then re-invokes with --yes.\n\nWith --yes:\n  1. hq sync push the project directory so the vault prefix exists\n  2. hq files share each manifest vaultPrefix to the recipient\n  3. read each grant back with hq files acl and match grantee + permission\n  4. advance manifest status building -> granted, stamping verifiedAt\n\nDirect ACL grants ONLY — this helper never mints a share-session URL\n(policy hq-delegate-never-inlines-secrets-or-share-urls).\n\nIdempotent: a prefix whose grant already exists is reported, not an error.\nA failed read-back exits non-zero and leaves manifest status unchanged.\n\n",
+    send: "hq-delegate-send.sh — generate the self-sufficient pickup prompt for a\ndelegation and deliver it by DM. The prompt IS the handoff: pasted into a\nfresh agent session on a clean HQ install, it pulls every file on demand\n(hq files get per prefix — no /hq-sync run) and reaches the first\nnext-step with no follow-up question to the delegator.\n\nUsage:\n  core/scripts/hq-delegate-send.sh --manifest <path> [--send]\n    [--headline <text>] [--note <text>]\n\nWithout --send: (re)generates PICKUP-PROMPT.md next to the manifest and\nprints its path — inspectable, idempotent, sends nothing.\nWith --send: requires manifest status \"verified\" (the US-008 probe must\nhave passed), then delivers ONE `hq dm` with --prompt-file/--details-file\nand advances status to \"sent\", recording the DM eventId.\n\nThe caller (the /delegate skill) humanizes --headline / --note per\ncore/knowledge/public/hq-core/humanize-before-send.md (channel dm, light)\nBEFORE invoking; this helper never rewrites recipients, flags, or the\ngenerated command lines.\n\nFail-closed: the generated prompt is scanned for secret-shaped content and\nshare-session URLs; a match aborts before anything is written or sent\n(policy hq-delegate-never-inlines-secrets-or-share-urls).\n\n",
+    verify: "hq-delegate-verify.sh — prove a delegation can actually be picked up\nbefore anyone is told it is theirs, or print the full plan without\ntouching anything.\n\nUsage (probe mode — after grants, before the DM):\n  core/scripts/hq-delegate-verify.sh --manifest <path>\n\nProbes every manifest vaultPrefix with `hq files browse` and requires it\nreachable AND non-empty. All pass -> manifest advances granted -> verified\n(send is gated on this). Any failure -> non-zero, the failing prefix and\nlikely cause named, status left at its last successful value so a re-run\nresumes without re-granting.\n\nUsage (dry-run mode — full plan, zero mutation):\n  core/scripts/hq-delegate-verify.sh --dry-run \\\n    --company <slug> --project <name> --to <principal> [--mode transfer|share]\n\nPrints recipient, mode, every prefix with its permission, the secret\nnames an .env.schema would grant, repo + branch, and the DM headline that\nwould be sent. Exits 0. Creates nothing under workspace/delegations/ and\ninvokes no mutating command.\n\nEnv: HQ_ROOT — HQ root override (default: resolved from script location)\n",
+    publish: "usage: --manifest <path>",
+};
+function out(value) { process.stdout.write(value); }
+function err(value) { process.stderr.write(value); }
+function fail(name, message) {
+    err(`hq-delegate-${name}: ${message}\n`);
+    return 1;
+}
+function text(value, fallback = "") {
+    if (value === undefined || value === null)
+        return fallback;
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "object")
+        return serializeJqJson(value, "pretty").replace(/\n+$/, "");
+    return String(value);
+}
+function list(value) { return Array.isArray(value) ? value : []; }
+function currentTime() {
+    const value = process.env.HQ_DELEGATE_NOW;
+    const date = value === undefined ? new Date() : new Date(value);
+    return Number.isNaN(date.getTime()) ? "Invalid Date" : date.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function jsonFile(file) {
+    try {
+        const value = readJsonFile(file);
+        return isRecord(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function malformedJsonFile(file) {
+    try {
+        JSON.parse(fs.readFileSync(file, "utf8"));
+        return false;
+    }
+    catch (error) {
+        return error instanceof SyntaxError;
+    }
+}
+function jsonText(value) { return serializeJqJson(value, "pretty"); }
+function checksum(file) {
+    return createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+function safeFiles(root) {
+    const result = [];
+    const visit = (directory) => {
+        for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+            const file = path.join(directory, entry.name);
+            if (entry.isDirectory())
+                visit(file);
+            else if (entry.isFile() && entry.name !== ".DS_Store")
+                result.push(file);
+        }
+    };
+    visit(root);
+    return result.sort().slice(0, 200);
+}
+function secretScan(name, files) {
+    let bad = false;
+    for (const file of files) {
+        if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+            continue;
+        const value = fs.readFileSync(file, "utf8");
+        for (const pattern of matchingSecretPatterns(value)) {
+            err(`secret-scan: pattern '${pattern}' matched in ${file}\n`);
+            bad = true;
+        }
+    }
+    return !bad;
+}
+function getPath(value, dotted, fallback) {
+    const found = jsonAt(value, dotted);
+    return found === undefined ? fallback : found;
+}
+function jqTrue(value) { return value !== undefined && value !== null && value !== false; }
+function quoteBash(value) {
+    if (value === "")
+        return "''";
+    if (/^[A-Za-z0-9_./:@+-]+$/.test(value))
+        return value;
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function delegationGroupId(principal) {
+    return "grp_dlg" + createHash("sha256").update(principal).digest("hex").slice(0, 32);
+}
+function stripAnsiSequences(value) {
+    const escape = String.fromCharCode(27);
+    return value.replace(new RegExp(`${escape}\\[[0-?]*[ -/]*[@-~]`, "g"), "");
+}
+function groupMemberIds(output) {
+    const plainOutput = stripAnsiSequences(output);
+    const lines = plainOutput.split(/\r?\n/);
+    const header = lines.findIndex((line) => /^PERSON_UID(?:\s|$)/.test(line.trimStart()));
+    if (header < 0)
+        return null;
+    return lines.slice(header + 1).filter((line) => line.trim() !== "")
+        .map((line) => line.trim().split(/\s{2,}/, 1)[0] ?? "");
+}
+function browseContainsExactKey(listing, expected) {
+    const lines = listing.split(/\r?\n/);
+    const aclLabels = Object.values(ACL_SOURCE_DISPLAY_LABELS);
+    return lines.slice(2).some((line) => {
+        const row = stripAnsiSequences(line).trimEnd();
+        const acl = aclLabels.find((label) => row.endsWith(label));
+        if (!acl)
+            return false;
+        const beforeAcl = row.slice(0, -acl.length).trimEnd();
+        const modifiedMatch = /^(.*) +(\S+)$/.exec(beforeAcl);
+        if (!modifiedMatch)
+            return false;
+        const modified = modifiedMatch[2] ?? "";
+        if (modified !== "—" && !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(modified))
+            return false;
+        const beforeModified = (modifiedMatch[1] ?? "").trimEnd();
+        const sizeMatch = /^(.*) +(\d+)$/.exec(beforeModified);
+        return (sizeMatch?.[1] ?? "").trimEnd() === expected;
+    });
+}
+function parseFlags(args, allowed) {
+    const values = {};
+    for (let i = 0; i < args.length;) {
+        const key = args[i] ?? "";
+        if (key === "-h" || key === "--help")
+            return { values, help: true };
+        if (!allowed.includes(key))
+            return { values, error: `unknown argument: ${key}` };
+        if (key === "--yes" || key === "--send" || key === "--dry-run") {
+            values[key] = true;
+            i += 1;
+        }
+        else {
+            values[key] = args[i + 1] ?? "";
+            i += 2;
+        }
+    }
+    return { values };
+}
+function usage(name) { return USAGE[name] ?? ""; }
+function usageFailure(name) { err(usage(name)); return 1; }
+function runShellFallback(name, args, context) {
+    const result = runBundledScript({
+        asset: ASSETS[name],
+        args,
+        cwd: context.cwd,
+        hqRoot: context.root ?? context.cwd,
+        captureOutput: true,
+    });
+    if (result.stdout?.length)
+        process.stdout.write(result.stdout);
+    if (result.stderr?.length)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+function runBundle(args, context, onMalformedWhoami) {
+    const root = context.root ?? context.cwd;
+    if (args[0] !== "build")
+        return usageFailure("bundle");
+    const parsed = parseFlags(args.slice(1), ["--company", "--project", "--to", "--to-kind", "--to-name", "--mode", "--dry-run"]);
+    if (parsed.help) {
+        out(usage("bundle"));
+        return 0;
+    }
+    if (parsed.error)
+        return fail("bundle", parsed.error);
+    const company = text(parsed.values["--company"]);
+    const project = text(parsed.values["--project"]);
+    const recipient = text(parsed.values["--to"]);
+    const toKind = text(parsed.values["--to-kind"], "person");
+    const toName = text(parsed.values["--to-name"]);
+    const mode = text(parsed.values["--mode"], "transfer");
+    const dryRun = parsed.values["--dry-run"] === true;
+    if (!company)
+        return fail("bundle", "--company is required");
+    if (!project)
+        return fail("bundle", "--project is required");
+    if (!recipient)
+        return fail("bundle", "--to is required");
+    if (mode !== "transfer" && mode !== "share")
+        return fail("bundle", "--mode must be transfer or share");
+    if (toKind !== "person" && toKind !== "agent")
+        return fail("bundle", "--to-kind must be person or agent");
+    const projectDir = path.join(root, "companies", company, "projects", project);
+    const prdPath = path.join(projectDir, "prd.json");
+    if (!fs.existsSync(projectDir) || !fs.statSync(projectDir).isDirectory())
+        return fail("bundle", `project directory not found: companies/${company}/projects/${project}`);
+    if (!fs.existsSync(prdPath) || !fs.statSync(prdPath).isFile())
+        return fail("bundle", `project has no prd.json: companies/${company}/projects/${project}/prd.json`);
+    let prd;
+    try {
+        prd = readJsonFile(prdPath);
+    }
+    catch {
+        return fail("bundle", `prd.json is not valid JSON: ${prdPath}`);
+    }
+    if (prd === null || prd === false)
+        return fail("bundle", `prd.json is not valid JSON: ${prdPath}`);
+    const who = subprocess("hq", ["whoami", "--json"], context.cwd, { stdout: "capture" });
+    if (who.code !== 0)
+        return fail("bundle", "could not read sender identity; update hq-cli if --json is unsupported");
+    let identity;
+    try {
+        identity = JSON.parse(who.stdout ?? "");
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return onMalformedWhoami ? onMalformedWhoami() : runShellFallback("bundle", args, context);
+        identity = undefined;
+    }
+    const identityValue = isRecord(identity) ? identity : {};
+    const identityReady = identityValue.authenticated !== false && [identityValue.email, identityValue.personUid, identityValue.agentUid].some((entry) => typeof entry === "string" && entry.length > 0);
+    if (!identityReady)
+        return fail("bundle", "sender identity is missing or expired; run hq login");
+    const fromEmail = text(identityValue.email) || null;
+    const fromUid = text(identityValue.personUid) || text(identityValue.agentUid) || null;
+    const knowledge = list(getPath(prd, "metadata.knowledge", [])).filter((entry) => typeof entry === "string").map(String);
+    const readPrefixes = [...new Set(knowledge.filter((entry) => entry.startsWith(`companies/${company}/`)).map((entry) => {
+            const relative = entry.slice(`companies/${company}/`.length);
+            if (relative.endsWith("/"))
+                return relative;
+            const slash = relative.lastIndexOf("/");
+            return slash < 0 ? "/" : relative.slice(0, slash + 1);
+        }))].sort();
+    const vaultPrefixes = [
+        { prefix: `projects/${project}/`, permission: "write", reason: "project dossier" },
+        ...readPrefixes.map((prefix) => ({ prefix, permission: "read", reason: "referenced knowledge/policies" })),
+    ].sort((a, b) => a.prefix.localeCompare(b.prefix));
+    if (vaultPrefixes.some(({ prefix }) => !prefix.endsWith("/") || prefix.startsWith("companies/")))
+        return fail("bundle", "internal error: derived a non-folder or company-anchored prefix");
+    const repoPath = text(getPath(prd, "metadata.repoPath"));
+    const repo = repoPath ? {
+        path: repoPath,
+        remote: null,
+        branch: text(getPath(prd, "branchName")) || null,
+        baseBranch: text(getPath(prd, "metadata.baseBranch"), "main") || "main",
+        headSha: null,
+        dirtyFiles: [],
+        accessVerified: false,
+    } : null;
+    const boardFile = path.join(root, "companies", company, "board.json");
+    let boardId = null;
+    const board = jsonFile(boardFile);
+    if (board) {
+        const projects = list(board.projects);
+        const boardEntry = projects.find((entry) => isRecord(entry) && entry.prd_path === `companies/${company}/projects/${project}/prd.json`);
+        if (isRecord(boardEntry) && jqTrue(boardEntry.id))
+            boardId = boardEntry.id;
+    }
+    const checksums = {};
+    for (const file of safeFiles(projectDir))
+        checksums[path.relative(root, file).split(path.sep).join("/")] = checksum(file);
+    const createdAt = currentTime();
+    const idTime = createdAt.replace(/[-:TZ]/g, "").slice(0, 8) + "-" + createdAt.slice(11, 19).replaceAll(":", "");
+    const delegationId = `dlg-${idTime}-${project}`;
+    const policies = knowledge.filter((entry) => entry.startsWith(`companies/${company}/policies/`));
+    const manifest = {
+        schemaVersion: 1,
+        delegationId,
+        createdAt,
+        mode,
+        from: { email: fromEmail, personUid: fromUid },
+        to: { kind: toKind, principal: recipient, displayName: toName || null },
+        company,
+        project: { name: project, prdPath: `companies/${company}/projects/${project}/prd.json`, boardId },
+        vaultPrefixes: vaultPrefixes.filter((entry, index, all) => all.findIndex((candidate) => candidate.prefix === entry.prefix) === index),
+        repo,
+        secrets: [],
+        knowledge: [...new Set(knowledge.filter((entry) => !entry.startsWith(`companies/${company}/policies/`)))].sort(),
+        policies: [...new Set(policies)].sort(),
+        checksums,
+        status: "building",
+    };
+    const description = text(getPath(prd, "description"), "No description recorded.");
+    const goal = text(getPath(prd, "metadata.goal"));
+    const stories = list(getPath(prd, "userStories", []));
+    const done = stories.filter((story) => isRecord(story) && story.passes === true);
+    const next = stories.filter((story) => !isRecord(story) || story.passes !== true)
+        .sort((a, b) => Number(getPath(a, "priority", 0)) - Number(getPath(b, "priority", 0))).slice(0, 3);
+    const doneList = done.map((story) => `- ${text(getPath(story, "id"))}: ${text(getPath(story, "title"))}`).join("\n");
+    const nextList = next.map((story) => `### ${text(getPath(story, "id"))}: ${text(getPath(story, "title"))}\n\n${text(getPath(story, "description"))}\n`).join("\n");
+    const questions = list(getPath(prd, "metadata.openQuestions", [])).map((entry) => `- ${text(entry)}`).join("\n");
+    const traps = [
+        ...list(getPath(prd, "metadata.securityNotes", [])),
+        ...list(getPath(prd, "metadata.executionConventions", [])),
+    ].map((entry) => `- ${text(entry)}`).join("\n");
+    let brief = `# Delegation brief — ${project}\n\nThis brief describes the **${project}** project in the **${company}** company. Completed handoff steps are recorded in the manifest. Pull the files and acknowledge receipt; report any access error to the sender.\n\n## What this project is\n\n${description}`;
+    if (goal)
+        brief += `\n\n## The goal\n\n${goal}`;
+    brief += `\n\n## Where things stand\n\n${done.length} of ${stories.length} stories are complete.`;
+    if (doneList)
+        brief += `\n\nAlready done:\n\n${doneList}`;
+    brief += `\n\n## The next three steps\n\n${nextList || "All stories are complete. Remaining work, if any, is described in the project's post-implementation notes."}`;
+    if (questions)
+        brief += `\n## Open questions\n\n${questions}\n`;
+    if (traps)
+        brief += `\n## Known traps and conventions\n\n${traps}\n`;
+    brief += `\n## Where everything lives\n\nThe full PRD (every story, acceptance criteria, and decision history) is at \`companies/${company}/projects/${project}/prd.json\`. The pickup prompt that accompanied this brief pulls every file you need on demand — you do not need to run a full sync.\n`;
+    const stage = fs.mkdtempSync(path.join(os.tmpdir(), "tmp-"));
+    const manifestFile = path.join(stage, "manifest.json");
+    const briefFile = path.join(stage, "BRIEF.md");
+    fs.writeFileSync(manifestFile, jsonText(manifest));
+    fs.writeFileSync(briefFile, brief);
+    if (!secretScan("bundle", [manifestFile, briefFile])) {
+        fs.rmSync(stage, { recursive: true, force: true });
+        return fail("bundle", "generated bundle matched a secret-detection pattern — nothing written (see stderr above)");
+    }
+    if (dryRun) {
+        out(fs.readFileSync(manifestFile, "utf8"));
+        fs.rmSync(stage, { recursive: true, force: true });
+        err("hq-delegate-bundle: dry run — nothing written\n");
+        return 0;
+    }
+    const dest = path.join(root, "workspace", "delegations", delegationId);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    moveFile(stage, dest);
+    out(`${delegationId}\n`);
+    err(`hq-delegate-bundle: wrote workspace/delegations/${delegationId}/{manifest.json,BRIEF.md}\n`);
+    return 0;
+}
+function runHq(args, context, stdout = "capture") {
+    return subprocess("hq", args, context.cwd, { stdout });
+}
+function commandSubstitutionBytes(value) {
+    const bytes = value.stdoutBytes ?? Buffer.from(value.stdout ?? "");
+    let end = bytes.length;
+    while (end > 0 && bytes[end - 1] === 0x0a)
+        end -= 1;
+    return bytes.subarray(0, end);
+}
+function emitJqParseDiagnostic(input, args, context) {
+    if (!commandExists("jq", context.cwd))
+        return;
+    const result = subprocess("jq", args, context.cwd, { input, stdout: "ignore", stderr: "pipe" });
+    const diagnostic = result.stderrBytes ?? Buffer.from(result.stderr ?? "");
+    if (diagnostic.length)
+        err(diagnostic);
+}
+const RESOLVE_FOUND_FILTER = '.status == "found" and (.person.personUid | type == "string") and (.person.companyUid | type == "string")';
+const RESOLVE_NOT_FOUND_FILTER = '.status == "not_found"';
+const ACL_FILTER = `
+    .schemaVersion == 1 and
+    (
+      .prefix == $prefix or
+      (($prefix | endswith("/*")) and .prefix == ($prefix | sub("\\\\*$"; "")))
+    ) and
+    (.companyUid | type == "string") and ($company == "" or .companyUid == $company) and
+    (.direct | type == "array") and (.exists | type == "boolean")
+  `;
+function runGrant(args, context) {
+    const parsed = parseFlags(args, ["--manifest", "--yes"]);
+    if (parsed.help) {
+        out(usage("grant"));
+        return 0;
+    }
+    if (parsed.error)
+        return fail("grant", parsed.error);
+    const manifestPath = text(parsed.values["--manifest"]);
+    const yes = parsed.values["--yes"] === true;
+    if (!manifestPath)
+        return fail("grant", "--manifest is required");
+    if (!fs.existsSync(manifestPath) || !fs.statSync(manifestPath).isFile())
+        return fail("grant", `manifest not found: ${manifestPath}`);
+    let manifest;
+    try {
+        manifest = readJsonFile(manifestPath);
+    }
+    catch {
+        return fail("grant", `manifest is not valid JSON: ${manifestPath}`);
+    }
+    if (manifest === null || manifest === false)
+        return fail("grant", `manifest is not valid JSON: ${manifestPath}`);
+    if (!isRecord(manifest))
+        return fail("grant", "manifest has no company");
+    const company = jqRawPath(manifest, "company");
+    const project = jqRawPath(manifest, "project.name");
+    const principal = jqRawPath(manifest, "to.principal");
+    const display = jqRawPaths(manifest, ["to.displayName", "to.principal"]);
+    const status = jqRawPath(manifest, "status");
+    if (!company)
+        return fail("grant", "manifest has no company");
+    if (!project)
+        return fail("grant", "manifest has no project.name");
+    if (!principal)
+        return fail("grant", "manifest has no to.principal");
+    let grantPrincipal = principal;
+    if (principal.startsWith("agt_")) {
+        const legacyGroup = "grp_dlg-" + principal.slice(-9).toLowerCase();
+        const nextGroup = delegationGroupId(principal);
+        const recordedGroup = text(getPath(manifest, "grantPrincipal"));
+        grantPrincipal = recordedGroup === legacyGroup || recordedGroup === nextGroup ? recordedGroup : nextGroup;
+    }
+    if (status !== "building" && status !== "granted")
+        return fail("grant", `manifest status is '${status}' — grants run from 'building' (or re-run from 'granted'), not from there`);
+    const prefixes = list(getPath(manifest, "vaultPrefixes"));
+    if (prefixes.length === 0)
+        return fail("grant", "manifest has no vaultPrefixes");
+    const badPrefixes = prefixes.filter((entry) => {
+        const prefix = jqRawPath(entry, "prefix");
+        return !prefix.endsWith("/") || prefix.startsWith("companies/") || prefix.startsWith("/");
+    }).map((entry) => jqRawPath(entry, "prefix"));
+    if (badPrefixes.length)
+        return fail("grant", `prefix violates the hq-files prefix conventions (must be company-relative folder form ending in '/'): ${badPrefixes.join("\n")}`);
+    out(`Delegation grant plan — company '${company}', recipient '${principal}':\n`);
+    if (grantPrincipal !== principal)
+        out(`  0. Agent recipient: grants flow through group ${grantPrincipal} (created if absent, containing exactly ${display})\n`);
+    out(`  1. Push companies/${company}/projects/${project}/ to the vault (on-conflict keep)\n`);
+    for (const entry of prefixes)
+        out(`  2. Grant ${jqRawPath(entry, "permission")} on ${jqRawPath(entry, "prefix")} — ${jqRawPath(entry, "reason")}\n`);
+    const writePrefixes = prefixes.map((entry) => jqRawPath(entry, "permission") === "write" ? jqRawPath(entry, "prefix") : "").filter(Boolean);
+    if (writePrefixes.length) {
+        out(`\nNOTE: granting 'write' is a privilege escalation. The recipient will be able\nto upload, overwrite, and delete under: ${writePrefixes.map((prefix) => `${prefix} `).join("")}\n`);
+    }
+    if (!yes) {
+        out("\n");
+        err("hq-delegate-grant: confirmation required — re-run with --yes after the user approves\n");
+        return 2;
+    }
+    let result = runHq(["sync", "push", `companies/${company}/projects/${project}/`, "--company", company, "--on-conflict", "keep"], context, "inherit");
+    if (result.code !== 0)
+        return fail("grant", `vault push failed for companies/${company}/projects/${project}/`);
+    const referencePaths = [
+        ...list(getPath(manifest, "knowledge", [])),
+        ...list(getPath(manifest, "policies", [])),
+    ].filter((entry) => typeof entry === "string" && entry.startsWith(`companies/${company}/`));
+    for (const reference of referencePaths) {
+        if (fs.existsSync(path.join(context.root ?? context.cwd, reference))) {
+            result = runHq(["sync", "push", reference, "--company", company, "--on-conflict", "keep"], context, "inherit");
+            if (result.code !== 0)
+                return fail("grant", `vault push failed for referenced knowledge: ${reference}`);
+        }
+        else {
+            err(`hq-delegate-grant: referenced path missing locally (cannot push): ${reference} — the verify probe will fail if it is not already in the vault\n`);
+        }
+    }
+    if (grantPrincipal !== principal) {
+        result = runHq(["groups", "create", grantPrincipal, "--name", `Delegation: ${display}`, "--company", company], context, "inherit");
+        if (result.code !== 0)
+            err("hq-delegate-grant: group create reported an error (may already exist) — continuing\n");
+        result = runHq(["groups", "add", grantPrincipal, principal, "--company", company], context, "inherit");
+        if (result.code !== 0)
+            err("hq-delegate-grant: group add reported an error (may already be a member) — continuing\n");
+        const members = subprocess("hq", ["groups", "members", grantPrincipal, "--company", company], context.cwd, { env: { NO_COLOR: "1", FORCE_COLOR: "0" } });
+        if (members.code !== 0)
+            return fail("grant", "could not verify delegation group membership");
+        const memberIds = groupMemberIds(members.stdout ?? "");
+        if (memberIds === null || memberIds.length !== 1 || memberIds[0] !== principal) {
+            return fail("grant", "delegation group membership does not exactly match recipient");
+        }
+    }
+    let expectedType = "";
+    let expectedId = "";
+    let expectedCompany = "";
+    if (grantPrincipal.startsWith("grp_")) {
+        expectedType = "group";
+        expectedId = grantPrincipal;
+    }
+    else if (grantPrincipal === "@all") {
+        expectedType = "company-wide";
+    }
+    else {
+        const resolved = runHq(["people", "resolve", principal, "--company", company, "--json", "--membership-only"], context);
+        let response;
+        try {
+            response = JSON.parse(resolved.stdout ?? "");
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                const input = commandSubstitutionBytes(resolved);
+                emitJqParseDiagnostic(input, ["-e", RESOLVE_FOUND_FILTER], context);
+                emitJqParseDiagnostic(input, ["-e", RESOLVE_NOT_FOUND_FILTER], context);
+            }
+            response = undefined;
+        }
+        if (isRecord(response) && response.status === "found" && isRecord(response.person) && typeof response.person.personUid === "string" && typeof response.person.companyUid === "string") {
+            if (resolved.code !== 0)
+                return fail("grant", "recipient resolution failed");
+            expectedType = "person";
+            expectedId = response.person.personUid;
+            expectedCompany = response.person.companyUid;
+        }
+        else if (isRecord(response) && response.status === "not_found") {
+            if (principal.includes("@")) {
+                expectedType = "email";
+                expectedId = principal.toLowerCase().trim();
+            }
+            else
+                return fail("grant", "unresolved recipient");
+        }
+        else
+            return fail("grant", "authoritative recipient lookup failed; update hq-cli if --membership-only is unsupported");
+    }
+    const readAcl = (prefix) => {
+        const response = runHq(["files", "acl", prefix, "--company", company, "--json"], context);
+        if (response.code !== 0)
+            return { ok: false };
+        let value;
+        try {
+            value = JSON.parse(response.stdout ?? "");
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                const input = commandSubstitutionBytes(response);
+                emitJqParseDiagnostic(input, ["-e", "--arg", "prefix", prefix, "--arg", "company", expectedCompany, ACL_FILTER], context);
+            }
+            value = undefined;
+        }
+        const rawPrefix = isRecord(value) ? value.prefix : undefined;
+        const expectedPrefix = prefix.endsWith("/*") ? prefix.slice(0, -1) : prefix;
+        if (!isRecord(value) || value.schemaVersion !== 1 || (rawPrefix !== prefix && rawPrefix !== expectedPrefix) || typeof value.companyUid !== "string" || (expectedCompany !== "" && value.companyUid !== expectedCompany) || !Array.isArray(value.direct) || typeof value.exists !== "boolean") {
+            err(`hq-delegate-grant: invalid structured ACL response for ${prefix}\n`);
+            return { ok: false };
+        }
+        return { value, ok: true };
+    };
+    const now = currentTime();
+    for (let i = 0; i < prefixes.length; i += 1) {
+        const entry = prefixes[i];
+        if (!isRecord(entry) || !isRecord(manifest))
+            return fail("grant", "manifest has an invalid vaultPrefixes entry");
+        const prefix = jqRawPath(entry, "prefix");
+        const permission = jqRawPath(entry, "permission");
+        const aclPattern = `${prefix}*`;
+        const before = readAcl(aclPattern);
+        if (!before.ok || !before.value)
+            return fail("grant", `ACL preflight failed; no share attempted for ${prefix}`);
+        expectedCompany = text(before.value.companyUid);
+        const share = runHq(["files", "share", aclPattern, "--with", grantPrincipal, "--permission", permission, "--company", company], context, "inherit");
+        const shareRc = share.code;
+        if (shareRc !== 0)
+            err(`hq-delegate-grant: share reported an error on ${prefix}; checking exact grant\n`);
+        let landed = false;
+        for (const delay of [0, 1, 2]) {
+            if (delay)
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay * 1000);
+            const after = readAcl(aclPattern);
+            if (after.ok && after.value?.exists === true && list(after.value.direct).some((row) => isRecord(row) && row.granteeType === expectedType && row.granteeId === expectedId && row.permission === permission)) {
+                landed = true;
+                break;
+            }
+        }
+        if (!landed)
+            return fail("grant", `grant outcome unconfirmed for ${principal} on ${prefix}; retain this manifest and resume`);
+        const current = list(manifest.vaultPrefixes)[i];
+        if (!isRecord(current))
+            return fail("grant", "manifest has an invalid vaultPrefixes entry");
+        current.verifiedAt = now;
+        current.grantReceipt = { companyUid: expectedCompany, granteeType: expectedType, granteeId: expectedId, shareExitCode: shareRc, verifiedAt: now };
+        writeJsonAtomically(manifestPath, manifest, true);
+        out(`hq-delegate-grant: verified ${permission} on ${prefix} for ${principal}\n`);
+    }
+    manifest.status = "granted";
+    manifest.grantPrincipal = grantPrincipal;
+    manifest.vaultPrefixes = list(manifest.vaultPrefixes).map((entry) => isRecord(entry) ? { ...entry, verifiedAt: now } : entry);
+    writeJsonAtomically(manifestPath, manifest, true);
+    out(`hq-delegate-grant: all ${prefixes.length} grants verified — manifest status advanced to 'granted'\n`);
+    return 0;
+}
+function atomicCopy(source, target) {
+    const temporary = `${target}.tmp.${process.pid}.${Math.random().toString(16).slice(2)}`;
+    try {
+        fs.copyFileSync(source, temporary);
+        moveFile(temporary, target);
+    }
+    catch (error) {
+        try {
+            fs.rmSync(temporary, { force: true });
+        }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], "atomic copy and cleanup failed");
+        }
+        throw error;
+    }
+}
+function fileRecord(key, value) { return serializeJqJson({ key, value }, "compact"); }
+function runPublish(args, context) {
+    if (args[0] !== "--manifest" || !args[1] || !fs.existsSync(args[1]) || !fs.statSync(args[1]).isFile())
+        return fail("publish", "usage: --manifest <path>");
+    const manifestPath = args[1];
+    if (malformedJsonFile(manifestPath))
+        return runShellFallback("publish", args, context);
+    let preflightManifest;
+    try {
+        preflightManifest = readJsonFile(manifestPath);
+    }
+    catch {
+        preflightManifest = undefined;
+    }
+    if (isRecord(preflightManifest) && jqRawPath(preflightManifest, "mode") === "transfer") {
+        const root = context.root ?? context.cwd;
+        const prd = path.join(root, "companies", jqRawPath(preflightManifest, "company"), "projects", jqRawPath(preflightManifest, "project.name"), "prd.json");
+        if (fs.existsSync(prd) && fs.statSync(prd).isFile() && malformedJsonFile(prd)) {
+            return runShellFallback("publish", args, context);
+        }
+    }
+    const lock = `${manifestPath}.send-lock`;
+    const lockHeld = args[2] === "--lock-held";
+    let ownLock = false;
+    if (lockHeld) {
+        if (!fs.existsSync(lock) || !fs.statSync(lock).isDirectory())
+            return fail("publish", "verification lock missing");
+    }
+    else {
+        try {
+            fs.mkdirSync(lock);
+            ownLock = true;
+        }
+        catch {
+            return fail("publish", "verification or delivery is active; retry after it finishes");
+        }
+        if (args.length !== 2) {
+            fs.rmdirSync(lock);
+            return fail("publish", "usage: --manifest <path>");
+        }
+    }
+    let stage = "";
+    const cleanup = () => {
+        if (stage)
+            fs.rmSync(stage, { recursive: true, force: true });
+        if (ownLock) {
+            try {
+                fs.rmdirSync(lock);
+            }
+            catch { /* a concurrent actor may have removed the lock */ }
+        }
+    };
+    try {
+        const manifest = jsonFile(manifestPath);
+        if (!manifest)
+            return fail("publish", `jq: error: ${manifestPath}: Invalid JSON`);
+        const company = jqRawPath(manifest, "company");
+        const project = jqRawPath(manifest, "project.name");
+        const id = jqRawPath(manifest, "delegationId");
+        if (!company || !project || !id)
+            return fail("publish", "jq: error: required manifest field missing");
+        for (const part of [company, project, id])
+            if (!/^[A-Za-z0-9_-][A-Za-z0-9._-]*$/.test(part))
+                return fail("publish", "unsafe path segment");
+        if (manifest.status !== "granted" && manifest.status !== "verified")
+            return fail("publish", "confirmed grants required");
+        if (jqRawPath(manifest, "mode") === "transfer" && manifest.ownershipTransferredAt == null)
+            return fail("publish", "transfer must finish before publication");
+        const root = context.root ?? context.cwd;
+        const relative = `companies/${company}/projects/${project}`;
+        const projectDir = path.join(root, relative);
+        const bundleDir = path.dirname(path.resolve(manifestPath));
+        const brief = path.join(bundleDir, "BRIEF.md");
+        const prd = path.join(projectDir, "prd.json");
+        if (!fs.existsSync(brief) || !fs.statSync(brief).isFile())
+            return fail("publish", "BRIEF.md missing");
+        if (!fs.existsSync(prd) || !fs.statSync(prd).isFile())
+            return fail("publish", "PRD missing");
+        if (jqRawPath(manifest, "mode") === "transfer") {
+            const expectedOwner = jqRawPath(manifest, "to.principal");
+            const prdValue = jsonFile(prd);
+            if (!prdValue || jqRawPath(prdValue, "metadata.owner") !== expectedOwner)
+                return fail("publish", "local PRD owner does not match recipient");
+        }
+        stage = fs.mkdtempSync(path.join(os.tmpdir(), "tmp-"));
+        const stagedBrief = path.join(stage, "BRIEF.md");
+        fs.copyFileSync(brief, stagedBrief);
+        const hashFile = path.join(stage, "hashes");
+        const hashed = {};
+        for (const file of [prd, path.join(projectDir, "README.md"), path.join(projectDir, "journal", "delegations.md")]) {
+            if (fs.existsSync(file) && fs.statSync(file).isFile()) {
+                const key = path.relative(root, file).split(path.sep).join("/");
+                hashed[key] = checksum(file);
+            }
+        }
+        const dest = path.join(projectDir, "delegation", id);
+        hashed[`${relative}/delegation/${id}/BRIEF.md`] = checksum(stagedBrief);
+        fs.writeFileSync(hashFile, `${Object.entries(hashed).map(([key, value]) => fileRecord(key, value)).join("\n")}\n`);
+        const canonical = { ...manifest, checksums: hashed, status: "granted", recipientAccess: "unconfirmed" };
+        delete canonical.publication;
+        delete canonical.verifiedAt;
+        delete canonical.sentAt;
+        delete canonical.dmEventId;
+        const stagedManifest = path.join(stage, "manifest.json");
+        fs.writeFileSync(stagedManifest, jsonText(canonical));
+        if (!secretScan("publish", [stagedManifest, stagedBrief]))
+            return fail("publish", "unsafe generated dossier");
+        const shareSession = /share-session\/[A-Za-z0-9_-]+/;
+        if (shareSession.test(fs.readFileSync(stagedManifest, "utf8")) || shareSession.test(fs.readFileSync(stagedBrief, "utf8")))
+            return fail("publish", "share-session capability in dossier; nothing published");
+        fs.mkdirSync(dest, { recursive: true });
+        atomicCopy(stagedBrief, path.join(dest, "BRIEF.md"));
+        atomicCopy(stagedManifest, path.join(dest, "manifest.json"));
+        atomicCopy(stagedManifest, manifestPath);
+        const push = runHq(["sync", "push", `${relative}/`, "--company", company, "--on-conflict", "keep"], context, "inherit");
+        if (push.code !== 0)
+            return fail("publish", "final dossier push failed; resume publication");
+        const receipts = { ...hashed };
+        receipts[`${relative}/delegation/${id}/manifest.json`] = checksum(path.join(dest, "manifest.json"));
+        const stagedRemote = path.join(stage, "remote");
+        for (const [file, expected] of Object.entries(receipts)) {
+            let matched = false;
+            const cloudPath = file.startsWith(`companies/${company}/`) ? file.slice(`companies/${company}/`.length) : file;
+            for (const delay of [0, 1, 2]) {
+                if (delay)
+                    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay * 1000);
+                const remote = runHq(["files", "cat", cloudPath, "--company", company], context);
+                if (remote.code === 0) {
+                    fs.writeFileSync(stagedRemote, remote.stdout ?? "");
+                    if (checksum(stagedRemote) === expected) {
+                        matched = true;
+                        break;
+                    }
+                }
+            }
+            if (!matched)
+                return fail("publish", `canonical cloud content differs or is unreadable: ${file}; resolve before sending`);
+        }
+        const publication = { verifiedAt: currentTime(), manifestPath: `${relative}/delegation/${id}/manifest.json`, files: receipts };
+        const updated = { ...canonical, publication, recipientAccess: "unconfirmed" };
+        fs.writeFileSync(stagedManifest, jsonText(updated));
+        atomicCopy(stagedManifest, manifestPath);
+        out("hq-delegate-publish: canonical dossier bytes verified as sender; recipient access unconfirmed\n");
+        return 0;
+    }
+    finally {
+        cleanup();
+    }
+}
+function sortedJson(value) {
+    const sort = (entry) => {
+        if (Array.isArray(entry))
+            return entry.map(sort);
+        if (!isRecord(entry))
+            return entry;
+        return Object.fromEntries(Object.keys(entry).sort().map((key) => [key, sort(entry[key])]));
+    };
+    return serializeJqJson(sort(value), "compact").replace(/\n+$/, "");
+}
+function runSend(args, context) {
+    const parsed = parseFlags(args, ["--manifest", "--send", "--headline", "--note"]);
+    if (parsed.help) {
+        out(usage("send"));
+        return 0;
+    }
+    if (parsed.error)
+        return fail("send", parsed.error);
+    const manifestPath = text(parsed.values["--manifest"]);
+    const send = parsed.values["--send"] === true;
+    let headline = text(parsed.values["--headline"]);
+    const note = text(parsed.values["--note"]);
+    if (!manifestPath)
+        return fail("send", "--manifest is required");
+    if (!fs.existsSync(manifestPath) || !fs.statSync(manifestPath).isFile())
+        return fail("send", `manifest not found: ${manifestPath}`);
+    const manifest = jsonFile(manifestPath);
+    if (!manifest)
+        return fail("send", `manifest is not valid JSON: ${manifestPath}`);
+    if (send) {
+        const publishedPath = path.join(context.root ?? context.cwd, jqRawPath(manifest, "publication.manifestPath"));
+        if (fs.existsSync(publishedPath) && fs.statSync(publishedPath).isFile() && malformedJsonFile(publishedPath)) {
+            return runShellFallback("send", args, context);
+        }
+    }
+    const lock = `${manifestPath}.send-lock`;
+    if (send) {
+        try {
+            fs.mkdirSync(lock);
+        }
+        catch {
+            return fail("send", "verification or delivery is active; retry after it finishes");
+        }
+    }
+    let lockRemoved = false;
+    const removeLock = () => {
+        if (!send || lockRemoved)
+            return;
+        try {
+            fs.rmdirSync(lock);
+            lockRemoved = true;
+        }
+        catch { /* Preserve the command result if a concurrent process removed it. */ }
+    };
+    try {
+        const bundleDir = path.dirname(path.resolve(manifestPath));
+        const brief = path.join(bundleDir, "BRIEF.md");
+        const prompt = path.join(bundleDir, "PICKUP-PROMPT.md");
+        const company = jqRawPath(manifest, "company");
+        const project = jqRawPath(manifest, "project.name");
+        const principal = jqRawPath(manifest, "to.principal");
+        const display = jqRawPaths(manifest, ["to.displayName", "to.principal"]);
+        const from = jqRawPaths(manifest, ["from.email", "from.personUid"], "your teammate");
+        const delegationId = jqRawPath(manifest, "delegationId");
+        const mode = jqRawPath(manifest, "mode", "transfer");
+        if (!company)
+            return fail("send", "manifest has no company");
+        if (!project)
+            return fail("send", "manifest has no project.name");
+        if (!principal)
+            return fail("send", "manifest has no to.principal");
+        const root = context.root ?? context.cwd;
+        const prdRelative = jqRawPath(manifest, "project.prdPath");
+        const prdAbs = path.join(root, prdRelative);
+        const prd = fs.existsSync(prdAbs) ? jsonFile(prdAbs) : undefined;
+        let goal = "";
+        let stateLine = "";
+        let nextSteps = "";
+        if (prd) {
+            goal = text(jqFallback(getPath(prd, "metadata.goal"), getPath(prd, "description", "")));
+            const stories = list(getPath(prd, "userStories", []));
+            const complete = stories.filter((entry) => isRecord(entry) && entry.passes === true).length;
+            stateLine = `${complete} of ${stories.length} stories are complete.`;
+            nextSteps = stories.filter((entry) => !isRecord(entry) || entry.passes !== true)
+                .sort((a, b) => Number(getPath(a, "priority", 0)) - Number(getPath(b, "priority", 0)))
+                .slice(0, 3)
+                .map((entry, index) => `${index + 1}. **${text(getPath(entry, "id"))}: ${text(getPath(entry, "title"))}** — ${text(getPath(entry, "description"))}`)
+                .join("\n");
+        }
+        const getLines = list(getPath(manifest, "vaultPrefixes", [])).map((entry) => "hq files get " + quoteBash(jqRawPath(entry, "prefix")) + " --company " + quoteBash(company)).join("\n");
+        let repoSection = "";
+        const repoValue = getPath(manifest, "repo");
+        if (repoValue !== null && repoValue !== undefined) {
+            const repoPath = jqRawPath(manifest, "repo.path");
+            const remote = jqRawPath(manifest, "repo.remote");
+            const branch = jqRawPath(manifest, "repo.branch");
+            const base = jqRawPath(manifest, "repo.baseBranch", "main") || "main";
+            const sha = jqRawPath(manifest, "repo.headSha");
+            const access = jqRawPath(manifest, "repo.accessNote");
+            const branchCheck = branch ? subprocess("git", ["check-ref-format", "--branch", branch], context.cwd, { stdout: "ignore", stderr: "ignore" }) : { code: 1 };
+            if (branch && branchCheck.code === 0 && sha) {
+                repoSection = `## Get the code\n\nThe work lives on branch \`${branch}\` (base: \`${base}\`) at \`${sha}\`.\n\n\`\`\`bash\n# From your HQ root; clone first if the repo is not present${remote ? ` (remote: ${remote})` : ""}:\ngit -C ${quoteBash(repoPath)} fetch origin\ngit -C ${quoteBash(repoPath)} switch -- ${quoteBash(branch)}\n\`\`\`${access ? `\n\n> ${access}` : ""}`;
+            }
+        }
+        const secretNames = list(getPath(manifest, "secrets", [])).map((entry) => text(entry)).join(",");
+        let secretsSection = "";
+        if (secretNames) {
+            secretsSection = `## Credentials\n\nYou have been granted read access to the secret names this project needs: \`${secretNames}\`. Values never travel in this handoff — consume them at runtime:\n\n\`\`\`bash\n# Inject from the project's .env.schema:\nhq run -- <your command>\n# Or explicitly by name:\nhq secrets exec --only ${secretNames} --company ${company} -- <your command>\n\`\`\`\n`;
+        }
+        if (!headline)
+            headline = `Project handoff: ${project} — open the brief, pull the files, and acknowledge receipt`;
+        const message = mode === "share"
+            ? `${from} has shared the **${project}** project (${company}) with you${note ? ` — ${note}` : ""}. You are working on it together; ownership stays with them.`
+            : `${from} has delegated the **${project}** project (${company}) to you${note ? ` — ${note}` : ""}. Transfer status is recorded in the dossier. Work Mesh ownership requires separate confirmation. Delegation id: \`${delegationId}\`.`;
+        let body = `# Project handoff: ${project}\n\n${message}\n\nCompleted grant and publication steps are recorded as receipts in the manifest. Sender-side checks do not prove your access: pull the files below and acknowledge receipt, or report any access error.\n\n`;
+        if (goal)
+            body += `## The goal\n\n${goal}\n\n`;
+        if (stateLine)
+            body += `## Where things stand\n\n${stateLine}\n\n`;
+        body += `## Pull the files (on demand — no sync)\n\nRun these from your HQ root; each materializes exactly that path locally:\n\n\`\`\`bash\n${getLines}\n\`\`\`\n\nStart with the project dossier: \`companies/${company}/projects/${project}/\` now contains the PRD (\`prd.json\`), a full brief (\`README.md\` / the DM's details pane), and the delegation journal.\n\n`;
+        if (repoSection)
+            body += `${repoSection}\n\n`;
+        if (secretsSection)
+            body += `${secretsSection}\n`;
+        if (nextSteps)
+            body += `## Your next three steps\n\n${nextSteps}\n\n`;
+        body += `## If something is off\n\nThe manifest and BRIEF.md are published under \`delegation/${delegationId}/\` within \`companies/${company}/projects/${project}/\`. If a pull fails or a path looks empty, report it to ${from}.\n`;
+        const stage = fs.mkdtempSync(path.join(os.tmpdir(), "tmp-"));
+        const stagedPrompt = path.join(stage, "PICKUP-PROMPT.md");
+        fs.writeFileSync(stagedPrompt, body);
+        if (!secretScan("send", [stagedPrompt, brief])) {
+            fs.rmSync(stage, { recursive: true, force: true });
+            return fail("send", "generated pickup prompt matched a secret-detection pattern — aborting, nothing written or sent");
+        }
+        const pattern = /share-session\/[A-Za-z0-9_-]+/;
+        if (pattern.test(fs.readFileSync(stagedPrompt, "utf8")) || (fs.existsSync(brief) && pattern.test(fs.readFileSync(brief, "utf8")))) {
+            fs.rmSync(stage, { recursive: true, force: true });
+            return fail("send", "a share-session URL appeared in a delegation artifact — forbidden (direct grants only), aborting");
+        }
+        moveFile(stagedPrompt, prompt);
+        fs.rmSync(stage, { recursive: true, force: true });
+        out(`hq-delegate-send: pickup prompt written: ${prompt}\n`);
+        if (!send)
+            return 0;
+        if (jqRawPath(manifest, "status") !== "verified")
+            return fail("send", `manifest status is '${jqRawPath(manifest, "status")}' — the reachability probe (hq-delegate-verify.sh) must pass before sending`);
+        if (!fs.existsSync(brief))
+            return fail("send", "BRIEF.md missing from the bundle — cannot send without the details pane");
+        const publication = getPath(manifest, "publication");
+        const publishedFiles = getPath(publication, "files");
+        if (getPath(publication, "verifiedAt") == null || !isRecord(publishedFiles) || Object.keys(publishedFiles).length === 0)
+            return fail("send", "verified publication receipt missing; run verification again");
+        for (const [file, expected] of Object.entries(publishedFiles)) {
+            const absolute = path.join(root, file);
+            if (!fs.existsSync(absolute) || checksum(absolute) !== text(expected))
+                return fail("send", `published artifact changed: ${file}; run verification again`);
+        }
+        const publishedManifestPath = path.join(root, jqRawPath(manifest, "publication.manifestPath"));
+        if (!fs.existsSync(publishedManifestPath))
+            return fail("send", "published manifest missing; run verification again");
+        const publishedManifest = jsonFile(publishedManifestPath);
+        if (!publishedManifest)
+            return fail("send", "published manifest missing; run verification again");
+        const normalized = { ...manifest, status: "granted", recipientAccess: "unconfirmed" };
+        delete normalized.publication;
+        delete normalized.verifiedAt;
+        delete normalized.sentAt;
+        delete normalized.dmEventId;
+        if (sortedJson(normalized) !== sortedJson(publishedManifest))
+            return fail("send", "manifest changed since publication; run verification again");
+        if (checksum(brief) !== checksum(path.join(path.dirname(publishedManifestPath), "BRIEF.md")))
+            return fail("send", "brief changed since publication; run verification again");
+        manifest.status = "sending";
+        writeJsonAtomically(manifestPath, manifest, true);
+        const dm = runHq(["dm", principal, headline, "--prompt-file", prompt, "--details-file", brief], context);
+        if (dm.code !== 0)
+            return fail("send", "hq dm delivery outcome is uncertain; status is sending, inspect DM history before retrying");
+        const event = /eventId[: ]+([A-Za-z0-9_-]+)/.exec(dm.stdout ?? "")?.[1] ?? "";
+        if (!event)
+            return fail("send", "DM response has no receipt; status is sending, reconcile DM history before retrying");
+        manifest.status = "sent";
+        manifest.sentAt = currentTime();
+        manifest.dmEventId = event;
+        writeJsonAtomically(manifestPath, manifest, true);
+        out(`hq-delegate-send: DM delivered to ${display} (${principal}) (eventId ${event}) — status advanced to 'sent'\n`);
+        return 0;
+    }
+    finally {
+        removeLock();
+    }
+}
+function sleepNative(milliseconds) {
+    if (milliseconds > 0)
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+function captureRun(run) {
+    const stdout = [];
+    const stderr = [];
+    const stdoutWrite = process.stdout.write.bind(process.stdout);
+    const stderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = ((chunk) => { stdout.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk)); return true; });
+    process.stderr.write = ((chunk) => { stderr.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk)); return true; });
+    try {
+        return { code: run(), stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr) };
+    }
+    finally {
+        process.stdout.write = stdoutWrite;
+        process.stderr.write = stderrWrite;
+    }
+}
+function runVerify(args, context) {
+    const parsed = parseFlags(args, ["--manifest", "--dry-run", "--company", "--project", "--to", "--mode"]);
+    if (parsed.help) {
+        out(usage("verify"));
+        return 0;
+    }
+    if (parsed.error)
+        return fail("verify", parsed.error);
+    const dryRun = parsed.values["--dry-run"] === true;
+    const root = context.root ?? context.cwd;
+    if (dryRun) {
+        const company = text(parsed.values["--company"]);
+        const project = text(parsed.values["--project"]);
+        const recipient = text(parsed.values["--to"]);
+        const mode = text(parsed.values["--mode"], "transfer");
+        if (!company)
+            return fail("verify", "--dry-run requires --company");
+        if (!project)
+            return fail("verify", "--dry-run requires --project");
+        if (!recipient)
+            return fail("verify", "--dry-run requires --to");
+        let malformedWhoamiFallbackCode;
+        const plan = captureRun(() => runBundle(["build", "--company", company, "--project", project, "--to", recipient, "--mode", mode, "--dry-run"], context, () => {
+            malformedWhoamiFallbackCode = runShellFallback("verify", args, context);
+            return malformedWhoamiFallbackCode;
+        }));
+        if (malformedWhoamiFallbackCode !== undefined) {
+            if (plan.stdout.length)
+                out(plan.stdout);
+            if (plan.stderr.length)
+                err(plan.stderr);
+            return malformedWhoamiFallbackCode;
+        }
+        if (plan.stderr.length)
+            err(plan.stderr);
+        if (plan.code !== 0)
+            return fail("verify", "could not derive the delegation plan (see builder error above)");
+        let manifest;
+        try {
+            manifest = JSON.parse(plan.stdout.toString("utf8"));
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                return runShellFallback("verify", args, context);
+            return fail("verify", "could not derive the delegation plan (see builder error above)");
+        }
+        const repoRelative = jqRawPath(manifest, "repo.path");
+        const candidates = [path.join(root, "companies", company, "projects", project, ".env.schema"), ...(repoRelative ? [path.join(root, repoRelative, ".env.schema")] : [])];
+        const schema = candidates.find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
+        let secretNames = "(none — no .env.schema found)";
+        if (schema) {
+            const names = [...new Set(fs.readFileSync(schema, "utf8").split(/\r?\n/).filter((line) => /^[A-Za-z_][A-Za-z0-9_]*=/.test(line)).map((line) => line.slice(0, line.indexOf("="))))].sort();
+            secretNames = names.length ? `${names.join(" ")} ` : "(none declared)";
+        }
+        out("Delegation dry run — nothing will be pushed, granted, transferred, or sent.\n\n");
+        out(`  Recipient:  ${recipient}\n  Mode:       ${mode}\n  Company:    ${company}\n  Project:    ${project}\n\n`);
+        out("  Vault grants that would be written:\n");
+        for (const entry of list(getPath(manifest, "vaultPrefixes", [])))
+            out(`    ${jqRawPath(entry, "permission")}\t on ${jqRawPath(entry, "prefix")}\t(${jqRawPath(entry, "reason")})\n`);
+        out(`\n  Secret names that would be granted (read): ${secretNames}\n\n`);
+        const repoValue = getPath(manifest, "repo");
+        if (repoValue !== null && repoValue !== undefined)
+            out(`  Repo handover: ${jqRawPath(manifest, "repo.path")} — branch ${jqRawPath(manifest, "repo.branch") || "(none)"} (base ${jqRawPath(manifest, "repo.baseBranch")})\n`);
+        else
+            out("  Repo handover: none (project has no repoPath)\n");
+        out(`\n  DM that would be sent to ${recipient}:\n    "Project handoff: ${project} is yours now — open details for the brief, paste the prompt into your agent to pick it up"\n    (prompt: generated pickup prompt; details: the delegation brief)\n`);
+        return 0;
+    }
+    const manifestPath = text(parsed.values["--manifest"]);
+    if (!manifestPath)
+        return fail("verify", "--manifest is required (or --dry-run with --company/--project/--to)");
+    if (!fs.existsSync(manifestPath) || !fs.statSync(manifestPath).isFile())
+        return fail("verify", `manifest not found: ${manifestPath}`);
+    if (malformedJsonFile(manifestPath))
+        return runShellFallback("verify", args, context);
+    const manifest = jsonFile(manifestPath);
+    if (!manifest)
+        return fail("verify", `jq: error: ${manifestPath}: Invalid JSON`);
+    const lock = `${manifestPath}.send-lock`;
+    try {
+        fs.mkdirSync(lock);
+    }
+    catch {
+        return fail("verify", "verification or delivery is active; retry after it finishes");
+    }
+    let cache = "";
+    try {
+        const company = jqRawPath(manifest, "company");
+        const status = jqRawPath(manifest, "status");
+        if (!company)
+            return fail("verify", "manifest has no company");
+        if (status !== "granted" && status !== "verified") {
+            if (status === "building")
+                return fail("verify", "manifest status is 'building' — run hq-delegate-grant.sh first (probe verifies grants, it cannot create them)");
+            return fail("verify", `manifest status is '${status}' — probe runs from 'granted' (or re-runs from 'verified')`);
+        }
+        const prefixes = list(getPath(manifest, "vaultPrefixes", []));
+        if (!prefixes.length)
+            return fail("verify", "manifest has no vaultPrefixes to probe");
+        out(`hq-delegate-verify: probing ${prefixes.length} prefix(es) in company '${company}'\n`);
+        let failed = false;
+        for (const entry of prefixes) {
+            const prefix = jqRawPath(entry, "prefix");
+            const browse = subprocess("hq", ["files", "browse", prefix, "--company", company], context.cwd, { stderr: "pipe" });
+            const combined = `${browse.stdout ?? ""}${browse.stderr ?? ""}`;
+            if (browse.code !== 0) {
+                out(`  FAIL  ${prefix} — browse errored (likely cause: the grant did not land, or the caller's session expired — re-run /hq-login and hq-delegate-grant.sh)\n`);
+                failed = true;
+            }
+            else if (!combined.replace(/\s/g, "") || combined.replace(/\s/g, "") === "Noobjectsunderthatprefix.") {
+                out(`  FAIL  ${prefix} — reachable but EMPTY (likely cause: the dossier was never pushed to the vault — hq sync push companies/${company}/... and re-run)\n`);
+                failed = true;
+            }
+            else
+                out(`  pass  ${prefix}\n`);
+        }
+        const refs = [...list(getPath(manifest, "knowledge", [])), ...list(getPath(manifest, "policies", []))]
+            .filter((entry) => typeof entry === "string" && entry.startsWith(`companies/${company}/`));
+        cache = fs.mkdtempSync(path.join(os.tmpdir(), "tmp-"));
+        const cacheMap = new Map();
+        const browseParent = (parent) => {
+            if (cacheMap.has(parent))
+                return cacheMap.get(parent) ?? "";
+            const retryCount = Number(process.env.HQ_DELEGATE_BROWSE_RETRIES ?? "3");
+            const sleepMs = Number(process.env.HQ_DELEGATE_BROWSE_RETRY_SLEEP ?? "2") * 1000;
+            let listing;
+            let attempt = 1;
+            while (true) {
+                const browse = subprocess("hq", ["files", "browse", parent, "--company", company], context.cwd, { stderr: "ignore" });
+                listing = browse.code === 0 ? browse.stdout ?? "" : "";
+                if (listing.replace(/\s/g, "") || attempt >= retryCount)
+                    break;
+                attempt += 1;
+                sleepNative(sleepMs);
+            }
+            cacheMap.set(parent, listing);
+            return listing;
+        };
+        if (refs.length) {
+            out(`hq-delegate-verify: probing ${refs.length} referenced knowledge/policy file(s)\n`);
+            for (const reference of refs) {
+                const relative = reference.slice(`companies/${company}/`.length);
+                const separator = relative.lastIndexOf("/");
+                const parent = `${separator < 0 ? "." : relative.slice(0, separator)}/`;
+                const listing = browseParent(parent);
+                if (browseContainsExactKey(listing, reference))
+                    out(`  pass  ${relative}\n`);
+                else {
+                    out(`  FAIL  ${relative} — granted prefix is reachable but this referenced file is NOT in the vault (likely cause: it was never pushed — hq sync push ${reference} --company ${company} and re-run)\n`);
+                    failed = true;
+                }
+            }
+        }
+        if (failed) {
+            err(`hq-delegate-verify: probe FAILED — the DM must not be sent; fix the failing prefix(es) above and re-run (manifest status left at '${status}')\n`);
+            return 1;
+        }
+        const publishCode = runPublish(["--manifest", manifestPath, "--lock-held"], context);
+        if (publishCode !== 0)
+            return fail("verify", "final dossier publication failed; notification blocked");
+        manifest.status = "verified";
+        manifest.verifiedAt = currentTime();
+        writeJsonAtomically(manifestPath, manifest, true);
+        out(`hq-delegate-verify: all ${prefixes.length} prefix(es) reachable — manifest status advanced to 'verified'\n`);
+        return 0;
+    }
+    finally {
+        if (cache)
+            fs.rmSync(cache, { recursive: true, force: true });
+        try {
+            fs.rmdirSync(lock);
+        }
+        catch { /* Keep the primary command result. */ }
+    }
+}
+export function runNativeDelegateW1b(name, args, context) {
+    switch (name) {
+        case "bundle": return runBundle(args, context);
+        case "grant": return runGrant(args, context);
+        case "publish": return runPublish(args, context);
+        case "send": return runSend(args, context);
+        case "verify": return runVerify(args, context);
+    }
+}
+/** Fast-entry adapter; the shared family flag is resolved before this module loads. */
+export function runDelegateW1bFast(args, _stdin, _cwd, hqRoot, commandName) {
+    const root = hqRoot ?? resolveLiveRoot();
+    const context = { cwd: root, root };
+    const saved = new Map();
+    for (const key of ["HQ_ROOT", "CLAUDE_PROJECT_DIR", "PWD"])
+        saved.set(key, process.env[key]);
+    process.env.HQ_ROOT = root;
+    process.env.CLAUDE_PROJECT_DIR = root;
+    process.env.PWD = root;
+    let code;
+    try {
+        code = runNativeDelegateW1b(commandName, [...args], context);
+    }
+    finally {
+        for (const [key, value] of saved) {
+            if (value === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = value;
+        }
+    }
+    if (code !== 0)
+        process.exitCode = code;
+    return code;
+}
+export function registerCoreDelegateW1b(delegate, core) {
+    for (const name of ["bundle", "grant", "publish", "send", "verify"]) {
+        const command = delegate.command(name)
+            .description(DESCRIPTIONS[name])
+            .allowUnknownOption()
+            .allowExcessArguments()
+            .helpOption(false)
+            .argument("[args...]", "arguments accepted for shell ABI compatibility")
+            .action(async (args = []) => {
+            const options = core.opts();
+            const root = resolveLiveRoot({ hqRoot: options.hqRoot });
+            const context = { cwd: root, root };
+            const { resolveProcessFlagGate } = await import("../lib/flag-registry.js");
+            if (!resolveProcessFlagGate(FLAG, { fallback: false }, () => false)) {
+                const result = runBundledScript({ asset: ASSETS[name], args, cwd: root, hqRoot: root });
+                if (result.code !== 0)
+                    process.exit(result.code);
+                return;
+            }
+            const saved = new Map();
+            for (const key of ["HQ_ROOT", "CLAUDE_PROJECT_DIR", "PWD"])
+                saved.set(key, process.env[key]);
+            process.env.HQ_ROOT = root;
+            process.env.CLAUDE_PROJECT_DIR = root;
+            process.env.PWD = root;
+            let code;
+            try {
+                code = runNativeDelegateW1b(name, args, context);
+            }
+            finally {
+                for (const [key, value] of saved) {
+                    if (value === undefined)
+                        delete process.env[key];
+                    else
+                        process.env[key] = value;
+                }
+            }
+            if (code !== 0)
+                process.exit(code);
+        });
+        describeCoreCommand(command, { execution: "native", asset: ASSETS[name], root: "live" });
+    }
+}
+//# sourceMappingURL=core-delegate-w1b.js.map