@agent-relay/factory 0.1.62 → 0.1.64

package/dist/cli/fleet.js

@@ -1,13 +1,14 @@
-import { existsSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import readline from 'node:readline/promises';
 import { ensureCloudSession } from '@agent-relay/cloud';
 import { stringifyLogValue } from '../logging.js';
 import { resolveLocalFactoryConfig } from '../config/local-clone-paths.js';
 import { initializeFactory } from './init.js';
-import { FileStateStore, RelayfileCloudMountClient, checkFactoryLoopLiveness, closeProbePr, createFactory, createFleet, createFactoryCloudEventV1, ensureRelayBroker, FactoryCloudReporter, FileFactoryCloudEventOutbox, defaultGhRunner, explicitLinkedIssueKey, githubIssuePathParts, githubWatchStatePath, isInFactoryScope, parseGithubFactoryIssue, publishFactoryMountHealth, heldAgentsFromRegistry, parseOwnedBrokerAgentExitTimeoutMs, parseStandaloneBabysitTarget, readStandalonePullRequest, readLinearIssueWithCanonicalFallback, reapFactoryOrphansOnce, reapFactoryEnvironmentsOnce, readFactoryInFlightRegistry, readFactoryLoopHeartbeat, resolveFactoryStates, stateResolutionFromIds, standaloneBabysitterAgentName, renderAgentTask, resolveFactoryWorkspace, } from '../index.js';
+import { FACTORY_EXIT, exitCodeForDispatchResult, exitCodeForError, exitCodeForIterationReport, exitCodeForLoopReports, exitCodeForRelayDispatch, } from './exit-codes.js';
+import { FileStateStore, RelayfileCloudMountClient, checkFactoryLoopLiveness, closeProbePr, createFactory, createFleet, createFactoryCloudEventV1, ensureRelayBroker, FactoryCloudReporter, FileFactoryCloudEventOutbox, defaultGhRunner, explicitLinkedIssueKey, githubIssuePathParts, githubWatchStatePath, isAllowedFactoryGithubDraft, isAllowedFactoryGithubArtifactDraft, isInFactoryScope, parseGithubFactoryIssue, publishFactoryMountHealth, heldAgentsFromRegistry, parseOwnedBrokerAgentExitTimeoutMs, parseStandaloneBabysitTarget, readStandalonePullRequest, readLinearIssueWithCanonicalFallback, reapFactoryOrphansOnce, reapFactoryEnvironmentsOnce, readFactoryInFlightRegistry, readFactoryLoopHeartbeat, resolveFactoryStates, stateResolutionFromIds, standaloneBabysitterAgentName, renderAgentTask, resolveFactoryWorkspace, } from '../index.js';
 import { resolveTestGuidance } from '../dispatch/test-guidance.js';
 import { FakeFleetClient, FakeMountClient } from '../testing/index.js';
 import { GitAgentWorktreeManager } from '../git/agent-worktree.js';
@@ -16,9 +17,10 @@ import { loadOrCreateFactoryInstanceId, resolveFactoryInstanceName } from '../ob
 import { ensureFactoryIntegrations, inspectFactoryIntegration, openIntegrationUrl, } from '../mount/relayfile-integration-preflight.js';
 import { checkMountStaleness } from '../mount/relayfile-binary.js';
 import { MountAuthScopeError } from '../mount/mount-auth-error.js';
+import { createHostedCloudAccessTokenProvider, hostedCloudAccessTokenUrl, resolveHostedCloudApiUrl, } from '../mount/relayfile-cloud-mount-client.js';
 import { resolveRelayWorkspaceKey } from '../fleet/relay-workspace-key.js';
 import { isMeaningfullyBehind, readFactoryVersionInfo, } from '../version-info.js';
-import { GhCliIssuePublisher, RelayChannelNotionClaimStore, RelayChannelNotionContractPublisher, loadNotionIntakeManifest, runNotionIntake, } from '../intake/index.js';
+import { GhCliIssuePublisher, NotionApiFactoryTasksClient, RelayChannelNotionClaimStore, RelayChannelNotionContractPublisher, generateFactoryTasksManifest, loadNotionIntakeManifest, runNotionIntake, } from '../intake/index.js';
 const autoDetectedIssueSources = new WeakSet();
 export async function runFleetCli(argv, deps = {}) {
     const out = deps.stdout ?? process.stdout;
@@ -51,6 +53,23 @@ export async function runFleetCli(argv, deps = {}) {
             await initializeFactory({ repo: command.repo, workspaceId: command.workspaceId, stdout: out, stderr: err });
             return 0;
         }
+        if (command.kind === 'notion-manifest') {
+            const notion = deps.notionFactoryTasks ?? new NotionApiFactoryTasksClient({
+                token: (deps.env ?? process.env).NOTION_API_KEY ?? '',
+            });
+            const manifest = await generateFactoryTasksManifest({
+                client: notion,
+                ...(command.dataSourceId ? { dataSourceId: command.dataSourceId } : {}),
+                ...(command.mountRoot ? { mountRoot: command.mountRoot } : {}),
+                ...(command.workerMountRoot ? { workerMountRoot: command.workerMountRoot } : {}),
+                ...(command.workerMountTransport
+                    ? { workerMountTransport: command.workerMountTransport }
+                    : {}),
+                ...(command.statePath ? { statePath: command.statePath } : {}),
+            });
+            writeJson(out, manifest);
+            return 0;
+        }
         if (command.kind === 'notion-intake') {
             const manifest = await loadNotionIntakeManifest(command.manifestPath);
             if (!globals.dryRun) {
@@ -133,7 +152,7 @@ export async function runFleetCli(argv, deps = {}) {
                 const workspaceId = (await (deps.resolveWorkspace ?? resolveFactoryWorkspace)()).workspaceId;
                 mount = deps.mount ?? await (deps.cloudMountFromConfig ?? RelayfileCloudMountClient.fromConfig)({
                     workspaceId,
-                    isAllowedDraft: (path, _content, opts) => isAllowedFactoryGithubDraft(path, opts),
+                    isAllowedDraft: (path, _content, opts) => isAllowedFactoryGithubArtifactDraft(path, opts),
                 });
                 await prepareFactoryIntegrations(command, mount, undefined, globals, deps, workspaceId, err);
                 githubWrite = mount.githubWrite;
@@ -264,10 +283,17 @@ export async function runFleetCli(argv, deps = {}) {
                 // A GitHub-only workspace has no /linear/states catalog and uses labels
                 // for lifecycle state, so it must not depend on that provider at startup.
                 const stateResolution = await resolveStatesForIssueSource(mount, loaded.config, deps.resolveStates);
-                const stateStore = new FileStateStore({
-                    batchSize: loaded.config.batchSize,
-                    watchStatePath: githubWatchStatePath(loaded.config.loop.registryPath),
-                });
+                const stateStore = deps.stateStoreFactory
+                    ? await deps.stateStoreFactory(loaded.config)
+                    : new FileStateStore({
+                        batchSize: loaded.config.batchSize,
+                        watchStatePath: githubWatchStatePath(loaded.config.loop.registryPath),
+                    });
+                // An injected backend is an explicit dispatch-admission dependency.
+                // It must prove readiness before Factory construction; a host adapter
+                // may never turn an unreadable durable store into an empty document.
+                if (deps.stateStoreFactory)
+                    await stateStore.assertReady();
                 reporter = deps.reporter ?? await buildFactoryCloudReporter({
                     config: loaded.config,
                     backend: globals.backend,
@@ -299,7 +325,7 @@ export async function runFleetCli(argv, deps = {}) {
                     reporter,
                     worktrees: globals.backend === 'internal' ? new GitAgentWorktreeManager() : undefined,
                 });
-                return await runFactoryCommand(command, factory, mount, fleet, loaded.config, globals, out, deps, workspaceId, acceptableMountIds);
+                return await runFactoryCommand(command, factory, mount, fleet, loaded.config, globals, out, deps, workspaceId, acceptableMountIds, stateStore.backend ? { backend: stateStore.backend } : undefined);
             }
         }
         return 1;
@@ -319,7 +345,7 @@ export async function runFleetCli(argv, deps = {}) {
             }
         }
         err.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        return 1;
+        return exitCodeForError(error);
     }
     finally {
         try {
@@ -393,6 +419,32 @@ function parseIntakeCommand(args) {
     const [source, manifestPath, ...rest] = args;
     if (source !== 'notion')
         throw new Error('factory intake currently requires the notion source');
+    if (manifestPath === 'generate') {
+        const parsed = parseFlags(rest);
+        const allowed = new Set([
+            'data-source',
+            'mount-root',
+            'worker-mount-root',
+            'worker-mount-transport',
+            'state-path',
+        ]);
+        const unexpected = Object.keys(parsed).find((key) => !allowed.has(key));
+        if (unexpected)
+            throw new Error(`Unknown Factory Tasks manifest option: --${unexpected}`);
+        const workerMountTransport = parsed['worker-mount-transport'];
+        if (workerMountTransport !== undefined &&
+            workerMountTransport !== 'local' && workerMountTransport !== 'relay-channel') {
+            throw new Error('--worker-mount-transport must be local or relay-channel');
+        }
+        return {
+            kind: 'notion-manifest',
+            ...(parsed['data-source'] ? { dataSourceId: parsed['data-source'] } : {}),
+            ...(parsed['mount-root'] ? { mountRoot: parsed['mount-root'] } : {}),
+            ...(parsed['worker-mount-root'] ? { workerMountRoot: parsed['worker-mount-root'] } : {}),
+            ...(workerMountTransport ? { workerMountTransport } : {}),
+            ...(parsed['state-path'] ? { statePath: parsed['state-path'] } : {}),
+        };
+    }
     if (!manifestPath)
         throw new Error('factory intake notion requires a manifest path');
     if (rest.length > 0)
@@ -489,7 +541,7 @@ export function parseGlobalOptions(argv) {
     }
     return { globals, args };
 }
-async function runFactoryCommand(command, factory, mount, fleet, config, globals, out, deps = {}, workspaceId = config.workspaceId ?? '', acceptableMountIds) {
+async function runFactoryCommand(command, factory, mount, fleet, config, globals, out, deps = {}, workspaceId = config.workspaceId ?? '', acceptableMountIds, stateStoreStatus) {
     const mountFn = resolveLocalMountFn(deps, mount);
     const mountStderr = deps.stderr ?? process.stderr;
     const debugMountRefreshes = (deps.env ?? process.env).FACTORY_LOG_LEVEL?.toLowerCase() === 'debug';
@@ -528,15 +580,20 @@ async function runFactoryCommand(command, factory, mount, fleet, config, globals
             // would only spawn agents against a read-denied mirror. Fail fast with the
             // remediation and resolve the command with a non-zero code.
             const warmMount = () => warmStartPathMounts(mount, mountFn, workspaceId, config, acceptableMountIds, mountStderr, debugMountRefreshes);
+            // Returns the code the failure classifies to, so the inline branch below
+            // can surface it directly. The background branch reads the same value
+            // back off the waiter; both must report one code for one failure.
             const handleWarmMountError = (error) => {
                 if (error instanceof MountAuthScopeError) {
+                    const code = exitCodeForError(error);
                     mountStderr.write(`${error.message}\n`);
                     mountStderr.write('[factory] aborting startup: local mount cannot obtain its filesystem scopes.\n');
-                    void flushAndResolve(1);
-                    return;
+                    void flushAndResolve(code);
+                    return code;
                 }
                 const message = error instanceof Error ? error.message : String(error);
                 mountStderr.write(`[factory] warning: background relayfile mount warmup failed: ${message}\n`);
+                return FACTORY_EXIT.FAILED;
             };
             const removeSignalHandlers = installFactoryStopSignalHandlers(factory, {
                 exit: (code) => {
@@ -556,14 +613,14 @@ async function runFactoryCommand(command, factory, mount, fleet, config, globals
                             mountStderr.write('[factory] aborting startup: Relayfile workspace mirror could not be resolved.\n');
                             if (stoppedBySignal)
                                 return await waiter.promise;
-                            return 1;
+                            return FACTORY_EXIT.FAILED;
                         }
                     }
                     catch (error) {
-                        handleWarmMountError(error);
+                        const code = handleWarmMountError(error);
                         if (stoppedBySignal)
                             return await waiter.promise;
-                        return 1;
+                        return code;
                     }
                 }
                 else {
@@ -585,12 +642,13 @@ async function runFactoryCommand(command, factory, mount, fleet, config, globals
         }
         if (command.action === 'run-once') {
             await ensureWorkspaceMount(mount, mountFn, workspaceId, acceptableMountIds, mountStderr);
-            writeJson(out, await factory.runOnce({ dryRun: globals.dryRun }));
-            return 0;
+            const report = await factory.runOnce({ dryRun: globals.dryRun });
+            writeJson(out, report);
+            return exitCodeForIterationReport(report);
         }
         if (command.action === 'status') {
             const versionInfo = await safeFactoryVersionInfo(deps.versionInfo, Boolean(deps.versionInfo) || !hasInjectedFactoryRuntime(deps));
-            writeJson(out, await factoryStatusWithMountHealth(factory, mount, config.loop.heartbeatPath, config.loop.registryPath, config.loop.heartbeatStaleMs, versionInfo));
+            writeJson(out, await factoryStatusWithMountHealth(factory, mount, config.loop.heartbeatPath, config.loop.registryPath, config.loop.heartbeatStaleMs, versionInfo, stateStoreStatus));
             return 0;
         }
         if (command.action === 'loop-status') {
@@ -611,18 +669,20 @@ async function runFactoryCommand(command, factory, mount, fleet, config, globals
         const removeSignalHandlers = installFactoryStopSignalHandlers(factory, {
             processLike: deps.stopSignalProcessLike,
         });
+        let loopCode = FACTORY_EXIT.OK;
         try {
             const reports = await factory.runLoop({ dryRun: globals.dryRun });
+            loopCode = exitCodeForLoopReports(reports);
             writeJson(out, {
                 reports,
-                status: await factoryStatusWithMountHealth(factory, mount, config.loop.heartbeatPath, config.loop.registryPath, config.loop.heartbeatStaleMs),
+                status: await factoryStatusWithMountHealth(factory, mount, config.loop.heartbeatPath, config.loop.registryPath, config.loop.heartbeatStaleMs, undefined, stateStoreStatus),
             });
         }
         finally {
             removeSignalHandlers();
             await factory.stop();
         }
-        return 0;
+        return loopCode;
     }
     if (command.kind === 'factory-canary') {
         const report = await factory.runOnce({ dryRun: true });
@@ -647,15 +707,16 @@ async function runFactoryCommand(command, factory, mount, fleet, config, globals
         try {
             const result = await factory.dispatch(decision, { dryRun: false });
             writeJson(out, result);
-            await factory.waitForDispatchTerminal(result.issue);
-            return 0;
+            const terminalPhase = await factory.waitForDispatchTerminal(result.issue);
+            return exitCodeForRelayDispatch(result, terminalPhase);
         }
         finally {
             await factory.stop();
         }
     }
-    writeJson(out, await factory.dispatch(decision, { dryRun: globals.dryRun }));
-    return 0;
+    const dispatched = await factory.dispatch(decision, { dryRun: globals.dryRun });
+    writeJson(out, dispatched);
+    return exitCodeForDispatchResult(dispatched);
 }
 async function warmStartPathMounts(mount, mountFn, workspaceId, config, acceptableMountIds, stderr = process.stderr, debug = process.env.FACTORY_LOG_LEVEL?.toLowerCase() === 'debug') {
     const result = await ensureWorkspaceMount(mount, mountFn, workspaceId, acceptableMountIds, stderr);
@@ -829,7 +890,7 @@ async function ensureMountPath(mountFn, workspaceId, path, mountOpts, stderr, lo
 function resolveIntegrationsMountRoot(mount) {
     return mount.getLocalMountRoot?.() ?? resolve(process.cwd(), '.integrations');
 }
-async function factoryStatusWithMountHealth(factory, mount, heartbeatPath, registryPath, heartbeatStaleMs, versionInfo) {
+async function factoryStatusWithMountHealth(factory, mount, heartbeatPath, registryPath, heartbeatStaleMs, versionInfo, stateStoreStatus) {
     const status = factory.status();
     const [heartbeat, registry] = await Promise.all([
         readFactoryLoopHeartbeat(heartbeatPath),
@@ -851,6 +912,9 @@ async function factoryStatusWithMountHealth(factory, mount, heartbeatPath, regis
     const readinessReconcile = liveness.ok
         ? heartbeat?.readinessReconcile
         : observableStatus.readinessReconcile;
+    const fleetControlPlane = liveness.ok
+        ? heartbeat?.fleetControlPlane
+        : observableStatus.fleetControlPlane;
     const eventListener = liveness.ok
         ? heartbeat?.eventListener ?? {
             state: 'unknown',
@@ -862,13 +926,23 @@ async function factoryStatusWithMountHealth(factory, mount, heartbeatPath, regis
         };
     const health = mount.getLocalMountHealth?.();
     if (!health)
-        return { ...observableStatus, ...versionInfo, heldAgents, eventListener, readinessReconcile };
+        return {
+            ...observableStatus,
+            ...versionInfo,
+            ...(stateStoreStatus ? { stateStore: stateStoreStatus } : {}),
+            heldAgents,
+            eventListener,
+            readinessReconcile,
+            fleetControlPlane,
+        };
     return {
         ...observableStatus,
         ...versionInfo,
+        ...(stateStoreStatus ? { stateStore: stateStoreStatus } : {}),
         heldAgents,
         eventListener,
         readinessReconcile,
+        fleetControlPlane,
         localMountDegraded: health.degraded,
         ...(health.reason ? { localMountDegradedReason: health.reason } : {}),
         ...(health.localDir ? { localMountRoot: health.localDir } : {}),
@@ -1135,10 +1209,18 @@ function factoryReportingMode(command) {
 async function buildFactoryCloudReporter(input) {
     if (!input.config.reporting.enabled)
         return undefined;
-    if (hasInjectedFactoryRuntime(input.deps) && !input.deps.cloudSessionProvider)
+    const runtimeEnv = input.deps.env ?? process.env;
+    // Hosted mode is a usable endpoint, not a defined-but-blank variable: an
+    // empty value must fall through to the local-session path instead of
+    // reaching createHostedCloudAccessTokenProvider, which throws on `new URL('')`.
+    const hostedAccessTokenUrl = hostedCloudAccessTokenUrl(runtimeEnv);
+    if (hasInjectedFactoryRuntime(input.deps)
+        && !input.deps.cloudSessionProvider
+        && !hostedAccessTokenUrl)
         return undefined;
     try {
-        const activeWorkspace = await (input.deps.resolveWorkspace ?? resolveFactoryWorkspace)();
+        const activeWorkspace = await (input.deps.resolveWorkspace
+            ?? (() => resolveFactoryWorkspace(undefined, runtimeEnv)))();
         const activeWorkspaceIds = new Set([
             activeWorkspace.workspaceId,
             activeWorkspace.cloudWorkspaceId,
@@ -1147,14 +1229,29 @@ async function buildFactoryCloudReporter(input) {
             input.logger.warn?.('[factory] Cloud progress reporting skipped because the active account workspace differs from Factory config');
             return undefined;
         }
-        const session = await (input.deps.cloudSessionProvider ?? ensureCloudSession)({ interactive: false });
         const outboxPath = input.config.reporting.outboxPath
             ?? join(dirname(input.config.loop.registryPath), 'factory-cloud-events.json');
         const instanceId = await loadOrCreateFactoryInstanceId(`${outboxPath}.instance-id`);
         const instanceName = resolveFactoryInstanceName(input.config);
-        const cloudFetch = async (_request, init) => session.client.fetch('/api/v1/factory/events', init);
+        let apiUrl;
+        let getAccessToken;
+        let cloudFetch;
+        if (hostedAccessTokenUrl) {
+            apiUrl = resolveHostedCloudApiUrl(runtimeEnv);
+            getAccessToken = createHostedCloudAccessTokenProvider({
+                url: hostedAccessTokenUrl,
+                fetchImpl: input.deps.cloudAccessTokenFetch ?? fetch,
+            });
+            cloudFetch = input.deps.cloudReporterFetch;
+        }
+        else {
+            const session = await (input.deps.cloudSessionProvider ?? ensureCloudSession)({ interactive: false });
+            apiUrl = session.auth.apiUrl;
+            getAccessToken = async () => session.client.snapshot().accessToken;
+            cloudFetch = async (_request, init) => session.client.fetch('/api/v1/factory/events', init);
+        }
         return new FactoryCloudReporter({
-            apiUrl: session.auth.apiUrl,
+            apiUrl,
             instance: {
                 id: instanceId,
                 bootId: randomUUID(),
@@ -1167,8 +1264,8 @@ async function buildFactoryCloudReporter(input) {
                 },
             },
             outbox: new FileFactoryCloudEventOutbox({ path: outboxPath }),
-            getAccessToken: async () => session.client.snapshot().accessToken,
-            fetch: cloudFetch,
+            getAccessToken,
+            ...(cloudFetch ? { fetch: cloudFetch } : {}),
             logger: input.logger,
             batchSize: input.config.reporting.batchSize,
             requestTimeoutMs: input.config.reporting.requestTimeoutMs,
@@ -1194,7 +1291,9 @@ async function buildFleet(globals, loaded, deps) {
         return new FakeFleetClient();
     const cwd = process.cwd();
     const env = deps.env ?? process.env;
-    const connectionPath = resolveBrokerConnectionPath(cwd, env);
+    const connectionPath = globals.backend === 'internal'
+        ? resolveFactoryBrokerConnectionPath(cwd, env, loaded?.config.fleetHealth.requireDedicatedBroker ?? false)
+        : resolveBrokerConnectionPath(cwd, env);
     // An injected createFleet owns fleet construction entirely (tests), so skip the
     // real broker bootstrap.
     if (deps.createFleet) {
@@ -1271,6 +1370,51 @@ export function resolveBrokerConnectionPath(startCwd = process.cwd(), env = proc
         current = parent;
     }
 }
+export function resolveFactoryBrokerConnectionPath(startCwd = process.cwd(), env = process.env, requireDedicatedBroker = false) {
+    const connectionPath = resolveBrokerConnectionPath(startCwd, env);
+    if (!requireDedicatedBroker)
+        return connectionPath;
+    const explicitStateDir = env.AGENT_RELAY_STATE_DIR?.trim();
+    if (!explicitStateDir) {
+        throw new Error('fleetHealth.requireDedicatedBroker requires AGENT_RELAY_STATE_DIR to name Factory\'s isolated relay state directory');
+    }
+    const inheritedConnectionPath = resolveBrokerConnectionPath(startCwd, {
+        ...env,
+        AGENT_RELAY_STATE_DIR: '',
+    });
+    // Always reject the checkout-local path, even if broker discovery currently
+    // walks past it and finds an ancestor connection. An interactive relay
+    // started in this checkout can claim the local path later.
+    const sharedStateDirs = [
+        join(resolve(startCwd), '.agentworkforce', 'relay'),
+        ...(inheritedConnectionPath ? [dirname(inheritedConnectionPath)] : []),
+    ];
+    if (sharedStateDirs.some((stateDir) => sameFilesystemPath(explicitStateDir, stateDir))) {
+        throw new Error('AGENT_RELAY_STATE_DIR resolves to the project broker; choose a separate state directory for Factory');
+    }
+    return connectionPath;
+}
+function sameFilesystemPath(left, right) {
+    return canonicalPath(left) === canonicalPath(right);
+}
+function canonicalPath(path) {
+    const absolute = resolve(path);
+    const missingSegments = [];
+    let existingAncestor = absolute;
+    while (!existsSync(existingAncestor)) {
+        const parent = dirname(existingAncestor);
+        if (parent === existingAncestor)
+            return absolute;
+        missingSegments.unshift(basename(existingAncestor));
+        existingAncestor = parent;
+    }
+    try {
+        return resolve(realpathSync.native(existingAncestor), ...missingSegments);
+    }
+    catch {
+        return absolute;
+    }
+}
 async function prepareFactoryIntegrations(command, mount, config, globals, deps, workspaceId, err) {
     const connections = mount.integrationConnections;
     if (!connections)
@@ -1479,13 +1623,10 @@ async function isAllowedFactoryDraft(path, content, opts, mount, config) {
     if (/^\/slack\/channels\/[^/]+\/messages\/.+/u.test(path)) {
         return true;
     }
-    if (isAllowedFactoryGithubDraft(path, opts)) {
+    if (await isAllowedFactoryGithubDraft(path, content, opts, mount, config))
         return true;
-    }
     return false;
 }
-const isFactoryGithubWritebackPath = (path) => /^\/github\/repos\/[^/]+\/[^/]+\/(?:pull-requests\/factory-[^/]+\.json|refs\/(?:factory\.json|refs%2Fheads%2Ffactory%2F[^/]+\.json)|pulls\/[1-9]\d*\/close\.json)$/iu.test(path);
-const isAllowedFactoryGithubDraft = (path, opts) => opts?.guarded === true && isFactoryGithubWritebackPath(path);
 const scopeIssueFromDraftContent = (content) => ({
     title: typeof asRecord(content)?.title === 'string' ? asRecord(content)?.title : '',
     team: typeof asRecord(asRecord(content)?.team)?.key === 'string'
@@ -1933,6 +2074,8 @@ Commands:
   close-probe <PR>      Probe/close a PR for an issue
   featuremap check      Validate .agentworkforce/features/manifest.yaml
   intake notion <file>  Normalize mounted Notion specs into Factory work
+  intake notion generate
+                        Emit a manifest for Ready for Agent Factory Tasks
   fleet <command>       Low-level fleet commands: spawn, roster, release
 
 Options: