@north-light/crouter 0.3.220 → 0.3.222

package/dist/daemon/reconcilers/human-delivery-lane.js

@@ -0,0 +1,41 @@
+import { randomUUID } from 'node:crypto';
+import { claimActionDelivery, dueActionDeliveries } from '../../core/canvas/human-deliveries.js';
+import { emitEvent } from '../../core/events/emit.js';
+import { operationIdContext } from '../../core/events/operation-id.js';
+import { deliverAction } from '../human/deliver-action.js';
+/** One daemon-life identity for guarded action-delivery claims. */
+export const humanDeliveryDaemonInstanceId = randomUUID();
+/** Admit due action deliveries without making the daemon's serial tick await subprocesses. */
+export class HumanDeliveryLaneReconciler {
+    run(now, ctx) {
+        if (!ctx.lifecycle.acceptsDetachedWork())
+            return;
+        let due;
+        try {
+            due = dueActionDeliveries(now);
+        }
+        catch (error) {
+            operationIdContext.fresh(() => {
+                emitEvent({ level: 'error', event: 'human.action_delivery.scan_failed', error });
+            });
+            return;
+        }
+        for (const candidate of due) {
+            try {
+                const claimed = claimActionDelivery(candidate.requestId, now, humanDeliveryDaemonInstanceId);
+                if (claimed === null)
+                    continue;
+                ctx.lifecycle.registerDetached(deliverAction(claimed, humanDeliveryDaemonInstanceId).catch((error) => {
+                    operationIdContext.fresh(() => {
+                        emitEvent({ level: 'error', event: 'human.action_delivery.failed', error, fields: { request_id: claimed.requestId } });
+                    });
+                }));
+            }
+            catch (error) {
+                operationIdContext.fresh(() => {
+                    emitEvent({ level: 'error', event: 'human.action_delivery.claim_failed', error, fields: { request_id: candidate.requestId } });
+                });
+            }
+        }
+    }
+}

package/dist/daemon/review/finish.d.ts

@@ -40,8 +40,13 @@ export declare function completeRequestedSubmit(reviewId: string, opts: {
 /** The companion's turn ended: complete any submit the human left waiting on
  *  it. Never throws — a settlement directive must not depend on delivery. */
 export declare function completeCompanionRequestedSubmit(companionNodeId: string): Promise<void>;
-/** Cancel an open review once; ticket cancellation remains owned by the retained human-ticket finisher. */
-export declare function cancelReview(reviewId: string, args: {
+/** `disposition` rides through to the ticket result: the recipient closing a
+ * review in their inbox is a dismissal, while the requester withdrawing it
+ * stays a cancellation. */
+export interface ReviewCancellationArgs {
     reason?: string;
     actor?: string;
-}): Promise<ReviewCancellationFinishOutcome>;
+    disposition?: 'canceled' | 'dismissed';
+}
+/** Cancel an open review once; ticket cancellation remains owned by the retained human-ticket finisher. */
+export declare function cancelReview(reviewId: string, args: ReviewCancellationArgs): Promise<ReviewCancellationFinishOutcome>;

package/dist/daemon/review/finish.js

@@ -9,6 +9,7 @@ import { readReviewSource } from '../../core/review/document.js';
 import { signalReviewActivity } from '../../core/review/signal.js';
 import { approveReviewLocked, cancelReviewRow, getReview, getReviewByCompanion, markDelivered, markDeliveryError, markProjected, markProjectionError, requestReviewSubmit, requireVisibleReview, } from '../../core/review/store.js';
 import { ReviewOperationError } from '../../core/review/types.js';
+import { cancelPendingEntries } from '../../core/feed/inbox.js';
 import { emitEvent } from '../../core/events/emit.js';
 import { retireCompanion } from '../companion-retire.js';
 import { deliverNodeMessage } from '../messaging/node-message.js';
@@ -68,6 +69,7 @@ async function serializedFinish(reviewId, work) {
     }
 }
 async function finishApproved(review, result) {
+    retractSubmitQueuedNote(review);
     let current = requireVisibleReview(review.review_id);
     if (current.projected_at === null) {
         try {
@@ -93,6 +95,7 @@ async function finishApproved(review, result) {
     return requireVisibleReview(review.review_id);
 }
 async function finishCanceled(review, winningWrite, args) {
+    retractSubmitQueuedNote(review);
     let current = requireVisibleReview(review.review_id);
     let canceledTicket;
     if (current.origin_kind === 'inline') {
@@ -153,6 +156,21 @@ async function finishCanceled(review, winningWrite, args) {
     await retireCompanion(current.companion_node_id, 'canceled');
     return { record: requireVisibleReview(review.review_id), ...(canceledTicket === undefined ? {} : { ticket_result: canceledTicket }) };
 }
+const SUBMIT_QUEUED_NOTE = 'review-submit-queued';
+/** Retract an undelivered queued-submit note once the review is settling. The
+ *  note rides the deferred tier and so does not wake the origin, while the
+ *  terminal result goes live — without this the origin reads "result to
+ *  follow" only after it already acted on that result. */
+function retractSubmitQueuedNote(review) {
+    try {
+        cancelPendingEntries(review.origin_node_id, (entry) => entry.kind === 'message'
+            && entry.data?.['note'] === SUBMIT_QUEUED_NOTE
+            && entry.data?.['review_id'] === review.review_id);
+    }
+    catch (error) {
+        emitEvent({ level: 'warn', event: 'review.submit_queued_note.retract_failed', error });
+    }
+}
 /** Tell the origin its review was submitted but is finishing behind the
  *  companion. Deliberately deferred: the origin is told nothing is needed of
  *  it, so waking it to say so would be noise. The approval itself wakes it. */
@@ -163,7 +181,7 @@ async function noteSubmitQueued(review) {
             from: 'crtrd',
             mode: 'quiet',
             label: 'human review submitted — result to follow',
-            data: { review_id: review.review_id },
+            data: { review_id: review.review_id, note: SUBMIT_QUEUED_NOTE },
             runtime: { kind: 'review-queued', facts: {} },
             body: `The human submitted their review of \`${review.file}\`; the document is still being edited. `
                 + "You'll be notified with the result once the review completes. Nothing is needed from you now.",

package/dist/hook-authoring.d.ts

@@ -0,0 +1,75 @@
+export type HookJson = null | boolean | number | string | HookJson[] | {
+    [key: string]: HookJson;
+};
+export type HookPhase = 'before' | 'after' | 'replace';
+export interface HookContext {
+    cwd: string;
+    providedParams: string[];
+}
+interface HookRequestBase {
+    protocolVersion: 1;
+    op: string;
+    command: string[];
+    operationId: string;
+    input: {
+        [key: string]: HookJson;
+    };
+    context: HookContext;
+}
+export interface BeforeHookRequest extends HookRequestBase {
+    phase: 'before';
+}
+export interface AfterHookRequest extends HookRequestBase {
+    phase: 'after';
+    result: HookJson;
+}
+export interface ReplaceHookRequest extends HookRequestBase {
+    phase: 'replace';
+}
+export type HookRequest = BeforeHookRequest | AfterHookRequest | ReplaceHookRequest;
+export interface HookSuccess {
+    protocolVersion: 1;
+    ok: true;
+    result?: HookJson;
+}
+export interface HookError {
+    code: string;
+    message: string;
+    field?: string;
+    next?: string;
+}
+export interface HookFailure {
+    protocolVersion: 1;
+    ok: false;
+    error: HookError;
+}
+export type HookResponse = HookSuccess | HookFailure;
+export type HookHandler = (request: HookRequest) => HookResponse | Promise<HookResponse>;
+export type HookHandlers = Record<string, HookHandler>;
+export interface RunHookExecutableOptions {
+    stdin?: NodeJS.ReadableStream;
+    stdout?: NodeJS.WritableStream;
+    stderr?: NodeJS.WritableStream;
+}
+export interface LocalHookProcessOptions {
+    timeoutMs: number;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    input?: string | Uint8Array;
+}
+export interface LocalHookProcessSuccess {
+    ok: true;
+    stdout: string;
+}
+export type LocalHookProcessResult = LocalHookProcessSuccess | HookFailure;
+export interface ForwardHookOptions {
+    headers?: HeadersInit;
+    bearer?: string;
+    timeoutMs: number;
+    maxResponseBytes: number;
+}
+export declare function hookError(code: string, message: string, details?: Omit<HookError, 'code' | 'message'>): HookFailure;
+export declare function runHookExecutable(handlers: HookHandlers, options?: RunHookExecutableOptions): Promise<void>;
+export declare function runLocalHookProcess(argv: readonly string[], options: LocalHookProcessOptions): Promise<LocalHookProcessResult>;
+export declare function forwardHook(endpoint: string | URL, request: HookRequest, options: ForwardHookOptions): Promise<HookResponse>;
+export {};

package/dist/hook-authoring.js

@@ -0,0 +1,358 @@
+import { spawn } from 'node:child_process';
+import { Console } from 'node:console';
+import { posixProcessGroupSpawnOptions, terminateProcessGroup } from './hook-process.js';
+export function hookError(code, message, details = {}) {
+    return { protocolVersion: 1, ok: false, error: { code, message, ...details } };
+}
+export async function runHookExecutable(handlers, options = {}) {
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    let response;
+    try {
+        const raw = await readStream(stdin);
+        let value;
+        try {
+            value = JSON.parse(raw);
+        }
+        catch {
+            response = hookError('invalid_hook_request', 'stdin must contain one JSON hook request');
+            writeResponse(stdout, response);
+            return;
+        }
+        const request = validateRequest(value);
+        if (!request.valid) {
+            response = hookError('invalid_hook_request', request.message);
+            writeResponse(stdout, response);
+            return;
+        }
+        const handler = handlers[request.value.op];
+        if (handler === undefined) {
+            response = hookError('unsupported_hook_op', `no handler is registered for ${request.value.op}`);
+            writeResponse(stdout, response);
+            return;
+        }
+        try {
+            response = await withConsoleStdoutOnStderr(stderr, () => handler(request.value));
+        }
+        catch (error) {
+            stderr.write(`hook handler ${request.value.op} failed: ${describeError(error)}\n`);
+            response = hookError('hook_handler_failed', `handler failed for ${request.value.op}`);
+        }
+        const validated = validateResponse(response, request.value);
+        if (!validated.valid) {
+            stderr.write(`hook handler ${request.value.op} returned an invalid response: ${validated.message}\n`);
+            response = hookError('invalid_hook_response', validated.message);
+        }
+    }
+    catch (error) {
+        stderr.write(`hook executable failed: ${describeError(error)}\n`);
+        response = hookError('hook_executable_failed', 'hook executable could not read its request');
+    }
+    writeResponse(stdout, response);
+}
+export async function runLocalHookProcess(argv, options) {
+    const executable = argv[0];
+    if (executable === undefined || executable === '') {
+        return hookError('local_process_invalid', 'local process argv[0] must not be empty');
+    }
+    if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
+        return hookError('local_process_invalid_options', 'timeoutMs must be greater than zero');
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        let timedOut = false;
+        let closed = false;
+        let cleanupComplete = false;
+        let timeout;
+        const stdout = [];
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            resolve(result);
+        };
+        let child;
+        try {
+            child = spawn(executable, argv.slice(1), {
+                cwd: options.cwd,
+                env: options.env,
+                shell: false,
+                stdio: [options.input === undefined ? 'ignore' : 'pipe', 'pipe', 'inherit'],
+                ...posixProcessGroupSpawnOptions(),
+            });
+        }
+        catch (error) {
+            settle(hookError('local_process_spawn_failed', `could not start ${executable}: ${describeError(error)}`));
+            return;
+        }
+        const settleTimeout = () => {
+            if (timedOut && closed && cleanupComplete) {
+                settle(hookError('local_process_timeout', `${executable} did not finish within ${options.timeoutMs}ms`));
+            }
+        };
+        timeout = setTimeout(() => {
+            timedOut = true;
+            void terminateProcessGroup(child).then(() => {
+                cleanupComplete = true;
+                settleTimeout();
+            }, (error) => {
+                cleanupComplete = true;
+                settle(hookError('local_process_cleanup_failed', `could not stop ${executable}: ${describeError(error)}`));
+            });
+        }, options.timeoutMs);
+        child.stdout.on('data', (chunk) => stdout.push(chunk));
+        child.once('error', (error) => {
+            if (child.pid !== undefined)
+                return;
+            settle(hookError('local_process_spawn_failed', `could not start ${executable}: ${describeError(error)}`));
+        });
+        child.once('close', (code, signal) => {
+            closed = true;
+            if (timedOut) {
+                settleTimeout();
+                return;
+            }
+            if (code === 0) {
+                settle({ ok: true, stdout: Buffer.concat(stdout).toString('utf8') });
+                return;
+            }
+            const status = signal === null ? `exit code ${code ?? 'unknown'}` : `signal ${signal}`;
+            settle(hookError('local_process_failed', `${executable} exited with ${status}`));
+        });
+        if (options.input !== undefined && child.stdin !== null) {
+            child.stdin.end(options.input);
+        }
+    });
+}
+export async function forwardHook(endpoint, request, options) {
+    if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
+        return hookError('hook_forward_invalid_options', 'timeoutMs must be greater than zero');
+    }
+    if (!Number.isSafeInteger(options.maxResponseBytes) || options.maxResponseBytes <= 0) {
+        return hookError('hook_forward_invalid_options', 'maxResponseBytes must be a positive integer');
+    }
+    const headers = new Headers(options.headers);
+    if (!headers.has('content-type'))
+        headers.set('content-type', 'application/json');
+    if (options.bearer !== undefined)
+        headers.set('authorization', `Bearer ${options.bearer}`);
+    const controller = new AbortController();
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+    }, options.timeoutMs);
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(request),
+            signal: controller.signal,
+        });
+        const body = await readResponseBody(response, options.maxResponseBytes);
+        let value;
+        try {
+            value = JSON.parse(body);
+        }
+        catch {
+            return hookError('hook_forward_invalid_response', `hook endpoint returned invalid JSON (HTTP ${response.status})`);
+        }
+        // A valid protocol envelope is authoritative regardless of HTTP status.
+        const validated = validateResponse(value, request);
+        if (!validated.valid)
+            return hookError('hook_forward_invalid_response', `${validated.message} (HTTP ${response.status})`);
+        return validated.value;
+    }
+    catch (error) {
+        if (timedOut)
+            return hookError('hook_forward_timeout', `hook endpoint did not respond within ${options.timeoutMs}ms`);
+        if (error instanceof ResponseTooLargeError) {
+            return hookError('hook_forward_response_too_large', `hook endpoint exceeded ${options.maxResponseBytes} response bytes`);
+        }
+        return hookError('hook_forward_failed', `hook endpoint request failed: ${describeError(error)}`);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+const STDOUT_CONSOLE_METHODS = ['log', 'info', 'debug', 'dir', 'table', 'group', 'groupCollapsed'];
+async function withConsoleStdoutOnStderr(stderr, run) {
+    const redirected = new Console({ stdout: stderr, stderr, colorMode: false });
+    const original = new Map();
+    for (const method of STDOUT_CONSOLE_METHODS) {
+        original.set(method, console[method]);
+        console[method] = redirected[method].bind(redirected);
+    }
+    try {
+        return await run();
+    }
+    finally {
+        for (const method of STDOUT_CONSOLE_METHODS)
+            console[method] = original.get(method);
+    }
+}
+function writeResponse(stdout, response) {
+    stdout.write(`${JSON.stringify(response)}\n`);
+}
+async function readStream(stream) {
+    const chunks = [];
+    for await (const chunk of stream)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+}
+async function readResponseBody(response, maxBytes) {
+    if (response.body === null)
+        return '';
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw new ResponseTooLargeError();
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return new TextDecoder().decode(concatBytes(chunks, total));
+}
+function concatBytes(chunks, total) {
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return result;
+}
+function validateRequest(value) {
+    if (!isRecord(value))
+        return invalid('request must be an object');
+    if (!hasOnlyKeys(value, ['protocolVersion', 'op', 'phase', 'command', 'operationId', 'input', 'context', 'result'])) {
+        return invalid('request contains unknown fields');
+    }
+    if (value['protocolVersion'] !== 1)
+        return invalid('unsupported hook protocol version');
+    if (typeof value['op'] !== 'string' || value['op'] === '')
+        return invalid('op must be a non-empty string');
+    if (!isStringArray(value['command']) || value['command'].length === 0)
+        return invalid('command must be a non-empty string array');
+    if (typeof value['operationId'] !== 'string' || !/^[0-9a-f]{32}$/.test(value['operationId'])) {
+        return invalid('operationId must be a 32-character lowercase hexadecimal string');
+    }
+    if (!isRecord(value['input']) || !isJson(value['input']))
+        return invalid('input must be a JSON object');
+    if (!isContext(value['context']))
+        return invalid('context must contain cwd and providedParams');
+    if (value['phase'] === 'after') {
+        if (!Object.hasOwn(value, 'result') || !isJson(value['result']))
+            return invalid('after requests require a JSON result');
+        return valid({
+            protocolVersion: 1,
+            op: value['op'],
+            phase: 'after',
+            command: value['command'],
+            operationId: value['operationId'],
+            input: value['input'],
+            context: value['context'],
+            result: value['result'],
+        });
+    }
+    if (value['phase'] !== 'before' && value['phase'] !== 'replace')
+        return invalid('phase must be before, after, or replace');
+    if (Object.hasOwn(value, 'result'))
+        return invalid('only after requests may contain result');
+    return valid({
+        protocolVersion: 1,
+        op: value['op'],
+        phase: value['phase'],
+        command: value['command'],
+        operationId: value['operationId'],
+        input: value['input'],
+        context: value['context'],
+    });
+}
+function validateResponse(value, request) {
+    if (!isRecord(value))
+        return invalid('response must be an object');
+    if (value['protocolVersion'] !== 1)
+        return invalid('response has an unsupported hook protocol version');
+    if (value['ok'] === true) {
+        if (!hasOnlyKeys(value, ['protocolVersion', 'ok', 'result']))
+            return invalid('successful response contains unknown fields');
+        const hasResult = Object.hasOwn(value, 'result');
+        if (request.phase === 'replace' && !hasResult)
+            return invalid('replace response requires result');
+        if (request.phase !== 'replace' && hasResult)
+            return invalid('only replace responses may contain result');
+        if (hasResult) {
+            const result = value['result'];
+            if (!isJson(result))
+                return invalid('response result must be JSON');
+            return valid({ protocolVersion: 1, ok: true, result });
+        }
+        return valid({ protocolVersion: 1, ok: true });
+    }
+    if (value['ok'] !== false || !hasOnlyKeys(value, ['protocolVersion', 'ok', 'error'])) {
+        return invalid('response must contain protocolVersion, ok, and error or result');
+    }
+    if (!isHookError(value['error']))
+        return invalid('response error must contain code and message strings');
+    return valid({ protocolVersion: 1, ok: false, error: value['error'] });
+}
+function isContext(value) {
+    return isRecord(value)
+        && hasOnlyKeys(value, ['cwd', 'providedParams'])
+        && typeof value['cwd'] === 'string'
+        && isStringArray(value['providedParams']);
+}
+function isHookError(value) {
+    return isRecord(value)
+        && hasOnlyKeys(value, ['code', 'message', 'field', 'next'])
+        && typeof value['code'] === 'string'
+        && value['code'] !== ''
+        && typeof value['message'] === 'string'
+        && value['message'] !== ''
+        && (value['field'] === undefined || typeof value['field'] === 'string')
+        && (value['next'] === undefined || typeof value['next'] === 'string');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function isJson(value) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJson);
+    return isRecord(value) && Object.values(value).every(isJson);
+}
+function hasOnlyKeys(value, keys) {
+    return Object.keys(value).every((key) => keys.includes(key));
+}
+function valid(value) {
+    return { valid: true, value };
+}
+function invalid(message) {
+    return { valid: false, message };
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+class ResponseTooLargeError extends Error {
+}

package/dist/hook-process.d.ts

@@ -0,0 +1,7 @@
+import type { ChildProcess } from 'node:child_process';
+export declare const PROCESS_GROUP_KILL_GRACE_MS = 250;
+export declare function posixProcessGroupSpawnOptions(): {
+    detached: true;
+};
+/** Signal the isolated group, then unconditionally reap survivors after grace. */
+export declare function terminateProcessGroup(child: ChildProcess, graceMs?: number): Promise<void>;

package/dist/hook-process.js

@@ -0,0 +1,34 @@
+export const PROCESS_GROUP_KILL_GRACE_MS = 250;
+export function posixProcessGroupSpawnOptions() {
+    if (process.platform === 'win32') {
+        throw new Error('hook process execution requires POSIX process groups');
+    }
+    return { detached: true };
+}
+/** Signal the isolated group, then unconditionally reap survivors after grace. */
+export async function terminateProcessGroup(child, graceMs = PROCESS_GROUP_KILL_GRACE_MS) {
+    const pid = child.pid;
+    if (pid === undefined)
+        return;
+    signalProcessGroup(pid, 'SIGTERM');
+    await delay(graceMs);
+    signalProcessGroup(pid, 'SIGKILL');
+}
+function signalProcessGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch (error) {
+        if (!isMissingProcess(error))
+            throw error;
+    }
+}
+function isMissingProcess(error) {
+    return typeof error === 'object'
+        && error !== null
+        && 'code' in error
+        && error.code === 'ESRCH';
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/index.d.ts

@@ -21,6 +21,8 @@ export type { CrtrError } from './core/errors.js';
 export { nowIso } from './core/fs-utils.js';
 export { validateOperationId, buildEnvelope, operationIdContext, errorClassCodes, serializeEventRecord, errorClassFromError, } from './core/events/index.js';
 export type { BuildEnvelopeInput, ErrorClass, ErrorClassCode, ErrorClassHints, EventComponent, EventEnvelope, EventError, EventField, EventLevel, EventOutcome, OperationId, OperationIdContext, RetryDisposition, } from './core/events/index.js';
+export { forwardHook, hookError, runHookExecutable, runLocalHookProcess } from './hook-authoring.js';
+export type { AfterHookRequest, BeforeHookRequest, ForwardHookOptions, HookContext, HookError, HookFailure, HookHandler, HookHandlers, HookJson, HookPhase, HookRequest, HookResponse, HookSuccess, LocalHookProcessOptions, LocalHookProcessResult, LocalHookProcessSuccess, ReplaceHookRequest, RunHookExecutableOptions, } from './hook-authoring.js';
 export { validateCommandManifest } from './core/command-manifests/manifest.js';
 export type { CommandManifestValidation, ValidatedCommandManifest } from './core/command-manifests/manifest.js';
 export type { CommandManifestIssue, TransportKind } from './core/command-manifests/schema.js';

package/dist/index.js

@@ -41,6 +41,8 @@ export { nowIso } from './core/fs-utils.js';
 // Pure envelope helpers only. Local source binding and canonical append remain
 // internal so package consumers cannot select crouter runtime file paths.
 export { validateOperationId, buildEnvelope, operationIdContext, errorClassCodes, serializeEventRecord, errorClassFromError, } from './core/events/index.js';
+// ── Hook authoring ───────────────────────────────────────────────────────
+export { forwardHook, hookError, runHookExecutable, runLocalHookProcess } from './hook-authoring.js';
 // ── Command-manifest compatibility ───────────────────────────────────────
 export { validateCommandManifest } from './core/command-manifests/manifest.js';
 export { validatePluginBundle } from './core/command-plugins/bundle.js';

package/dist/migrations/002-profile-project-memory.d.ts

@@ -0,0 +1,2 @@
+import type { ProfileManifestMigration } from './types.js';
+export declare const profileProjectMemoryMigration: ProfileManifestMigration;