forge-workflow 0.1.0-beta.4 → 0.1.0-beta.6

package/lib/capabilities/probes.js

@@ -0,0 +1,347 @@
+'use strict';
+
+const { createProbeResult } = require('./model');
+
+const PROBE_REVISION = 'forge.harness-capability-probe.v1';
+const DEFAULT_TIMEOUT_MS = 1500;
+const DEFAULT_MAX_OUTPUT_BYTES = 16 * 1024;
+const MAX_TIMEOUT_MS = 30 * 1000;
+const MAX_OUTPUT_BYTES = 64 * 1024;
+const EXECUTABLE_IDENTITY_PATTERN = /^[0-9a-f]{64}$/;
+const SECRET_PATTERNS = Object.freeze([
+  /gh[pousr]_[a-z0-9]{20,}/i,
+  /sk-(?:live-|test-)?[a-z0-9]{16,}/i,
+  /(?:api[_ -]?key|authorization|credential|password|private[_ -]?key|secret|token)\s*[:=]\s*\S{8,}/i,
+]);
+const PRIVATE_PATH_PATTERN = /(?:[a-z]:\\Users\\[^\\\s]+|\/(?:Users|home)\/[^/\s]+\/)/i;
+
+const HARNESS_IDS = Object.freeze(['claude', 'codex', 'cursor', 'hermes']);
+const CAPABILITY_IDS = Object.freeze([
+  'native_streaming_monitor',
+  'bounded_background_tasks',
+  'wake_resume',
+  'cancellation',
+  'session_scoped_cleanup',
+  'initiating_agent_delivery',
+]);
+
+function capability(id, probeId, args, requiredTokens) {
+  if (args.length === 0 || args.at(-1) !== '--help') {
+    throw new TypeError(`Capability probe ${probeId} must use a side-effect-free help command`);
+  }
+  return Object.freeze({
+    id,
+    probeId,
+    args: Object.freeze(args),
+    requiredTokens: Object.freeze(requiredTokens),
+  });
+}
+
+function harnessSpec(command, versionPattern, capabilities) {
+  return Object.freeze({
+    command,
+    versionArgs: Object.freeze(['--version']),
+    versionPattern,
+    capabilities: Object.freeze(capabilities),
+  });
+}
+
+const HARNESS_PROBE_SPECS = Object.freeze({
+  claude: harnessSpec('claude', /^(?:claude(?:\s+code)?\s+)?v?(\d+\.\d+\.\d+(?:[-+][0-9a-z.-]+)?)$/i, [
+    capability('native_streaming_monitor', 'claude.stream-json-help.v1', ['--help'], ['--output-format', 'stream-json']),
+    capability('bounded_background_tasks', 'claude.remote-help.v1', ['--help'], ['--remote']),
+    capability('wake_resume', 'claude.resume-help.v1', ['--help'], ['--resume']),
+    capability('cancellation', 'claude.cancel-help.v1', ['--help'], ['--cancel']),
+    capability('session_scoped_cleanup', 'claude.session-cleanup-help.v1', ['--help'], ['session', 'delete']),
+    capability('initiating_agent_delivery', 'claude.stream-delivery-help.v1', ['--help'], ['--output-format', 'stream-json']),
+  ]),
+  codex: harnessSpec('codex', /^(?:codex(?:-cli)?\s+)?v?(\d+\.\d+\.\d+(?:[-+][0-9a-z.-]+)?)$/i, [
+    capability('native_streaming_monitor', 'codex.json-help.v1', ['--help'], ['--json', 'output-schema']),
+    capability('bounded_background_tasks', 'codex.cloud-help.v1', ['cloud', '--help'], ['task']),
+    capability('wake_resume', 'codex.resume-help.v1', ['resume', '--help'], ['resume']),
+    capability('cancellation', 'codex.cloud-cancel-help.v1', ['cloud', '--help'], ['cancel']),
+    capability('session_scoped_cleanup', 'codex.cloud-cleanup-help.v1', ['cloud', '--help'], ['delete']),
+    capability('initiating_agent_delivery', 'codex.delivery-help.v1', ['--help'], ['event', 'initiating', 'agent']),
+  ]),
+  cursor: harnessSpec('cursor-agent', /^(?:cursor(?:-agent)?\s+)?v?(\d+\.\d+\.\d+(?:[-+][0-9a-z.-]+)?)$/i, [
+    capability('native_streaming_monitor', 'cursor.json-help.v1', ['--help'], ['--json']),
+    capability('bounded_background_tasks', 'cursor.background-help.v1', ['--help'], ['background']),
+    capability('wake_resume', 'cursor.resume-help.v1', ['resume', '--help'], ['resume']),
+    capability('cancellation', 'cursor.cancel-help.v1', ['cancel', '--help'], ['cancel']),
+    capability('session_scoped_cleanup', 'cursor.session-cleanup-help.v1', ['sessions', '--help'], ['sessions', 'delete']),
+    capability('initiating_agent_delivery', 'cursor.follow-up-help.v1', ['--help'], ['follow-up', 'initiating', 'agent']),
+  ]),
+  hermes: harnessSpec('hermes', /^(?:hermes(?:-agent)?\s+)?v?(\d+\.\d+\.\d+(?:[-+][0-9a-z.-]+)?)$/i, [
+    capability('native_streaming_monitor', 'hermes.monitor-help.v1', ['monitor', '--help'], ['monitor', 'stream']),
+    capability('bounded_background_tasks', 'hermes.cron-help.v1', ['cron', '--help'], ['cron', 'task']),
+    capability('wake_resume', 'hermes.resume-help.v1', ['resume', '--help'], ['resume']),
+    capability('cancellation', 'hermes.cron-cancel-help.v1', ['cron', '--help'], ['pause', 'remove']),
+    capability('session_scoped_cleanup', 'hermes.session-cleanup-help.v1', ['sessions', '--help'], ['sessions', 'delete']),
+    capability('initiating_agent_delivery', 'hermes.origin-delivery-help.v1', ['cron', '--help'], ['origin', 'deliver']),
+  ]),
+});
+
+function getHarnessProbeSpec(harness) {
+  const spec = HARNESS_PROBE_SPECS[harness];
+  if (!spec) throw new TypeError(`Unsupported harness: ${harness}`);
+  return spec;
+}
+
+function assertBoundedPositiveInteger(value, name, maximum) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
+    throw new TypeError(`${name} must be an integer between 1 and ${maximum}`);
+  }
+}
+
+function isHostileOutput(output) {
+  return SECRET_PATTERNS.some((pattern) => pattern.test(output))
+    || PRIVATE_PATH_PATTERN.test(output)
+    || [...output].some((character) => {
+      const code = character.codePointAt(0);
+      return (code >= 0 && code <= 8)
+        || code === 11
+        || code === 12
+        || (code >= 14 && code <= 31)
+        || code === 127;
+    });
+}
+
+function normalizeExecution(response, maxOutputBytes) {
+  if (!response || typeof response !== 'object' || Array.isArray(response)) {
+    return { complete: false, reason: 'MALFORMED_RESULT' };
+  }
+  if (response.timedOut === true) return { complete: false, reason: 'PROBE_TIMEOUT' };
+  if (response.errorCode === 'ENOENT') return { complete: false, reason: 'EXECUTABLE_UNAVAILABLE' };
+  if (typeof response.stdout !== 'string' || typeof response.stderr !== 'string') {
+    return { complete: false, reason: 'MALFORMED_RESULT' };
+  }
+  const outputBytes = Buffer.byteLength(response.stdout, 'utf8') + Buffer.byteLength(response.stderr, 'utf8');
+  if (outputBytes > maxOutputBytes) return { complete: false, reason: 'OUTPUT_LIMIT' };
+  const output = `${response.stdout}\n${response.stderr}`;
+  if (isHostileOutput(output)) return { complete: false, reason: 'HOSTILE_OUTPUT' };
+  if (response.exitCode !== 0) return { complete: false, reason: 'PROBE_FAILED' };
+  return {
+    complete: true,
+    stdout: response.stdout,
+    stderr: response.stderr,
+    executableIdentity: response.executableIdentity,
+  };
+}
+
+async function executeBounded(execute, requestBase, timeoutMs) {
+  const controller = new AbortController();
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      resolve({ timedOut: true, stdout: '', stderr: '' });
+    }, timeoutMs);
+  });
+  const request = Object.freeze({ ...requestBase, signal: controller.signal });
+  try {
+    return await Promise.race([
+      Promise.resolve().then(() => execute(request)),
+      timeout,
+    ]);
+  } catch (_error) {
+    return { exitCode: null, stdout: '', stderr: '', errorCode: 'EXECUTION_ERROR' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function requestFor({ harness, kind, probeId, command, args, timeoutMs, maxOutputBytes }) {
+  return {
+    harness,
+    kind,
+    probeId,
+    command,
+    args: Object.freeze([...args]),
+    timeoutMs,
+    maxOutputBytes,
+    sideEffectFree: true,
+  };
+}
+
+function incompleteCapabilities(spec, reason) {
+  return spec.capabilities.map((item) => ({
+    id: item.id,
+    available: false,
+    status: 'INCOMPLETE',
+    reason,
+    probe_id: item.probeId,
+  }));
+}
+
+function buildResult({ harness, spec, observedAt, status, availability, identity, version, capabilities }) {
+  return createProbeResult({
+    probeRevision: PROBE_REVISION,
+    harnessId: harness,
+    status,
+    availability,
+    observedAt,
+    executable: { command: spec.command, identity, version },
+    capabilities,
+  });
+}
+
+function parseVersion(stdout, pattern) {
+  const normalized = stdout.trim();
+  if (normalized.includes('\n') || normalized.includes('\r')) return null;
+  const match = pattern.exec(normalized);
+  return match ? match[1] : null;
+}
+
+function capabilityFromExecution(item, execution, identity) {
+  let status = 'INCOMPLETE';
+  let reason = execution.reason;
+  let available = false;
+  if (execution.complete && execution.executableIdentity !== identity) {
+    reason = 'EXECUTABLE_IDENTITY_CHANGED';
+  } else if (execution.complete) {
+    const output = execution.stdout.toLowerCase();
+    available = item.requiredTokens.every((token) => output.includes(token.toLowerCase()));
+    status = available ? 'AVAILABLE' : 'UNAVAILABLE';
+    reason = available ? 'PROBED_SUPPORTED' : 'PROBED_UNSUPPORTED';
+  }
+  return {
+    id: item.id,
+    available,
+    status,
+    reason,
+    probe_id: item.probeId,
+  };
+}
+
+async function probeCapability(item, context, cache) {
+  const { execute, harness, spec, timeoutMs, maxOutputBytes, identity } = context;
+  const cacheKey = JSON.stringify(item.args);
+  let response = cache.get(cacheKey);
+  if (!response) {
+    response = executeBounded(execute, requestFor({
+      harness,
+      kind: 'behavior',
+      probeId: item.probeId,
+      command: spec.command,
+      args: item.args,
+      timeoutMs,
+      maxOutputBytes,
+    }), timeoutMs);
+    cache.set(cacheKey, response);
+  }
+  const execution = normalizeExecution(await response, maxOutputBytes);
+  return capabilityFromExecution(item, execution, identity);
+}
+
+async function probeCapabilities(context) {
+  const cache = new Map();
+  const capabilities = [];
+  for (const item of context.spec.capabilities) {
+    capabilities.push(await probeCapability(item, context, cache));
+  }
+  return capabilities;
+}
+
+async function probeHarness(options) {
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new TypeError('probe options must be an object');
+  }
+  const { harness, execute } = options;
+  const spec = getHarnessProbeSpec(harness);
+  if (typeof execute !== 'function') throw new TypeError('execute must be a function');
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+  assertBoundedPositiveInteger(timeoutMs, 'timeoutMs', MAX_TIMEOUT_MS);
+  assertBoundedPositiveInteger(maxOutputBytes, 'maxOutputBytes', MAX_OUTPUT_BYTES);
+  const observedAt = options.observedAt ?? new Date().toISOString();
+
+  const versionResponse = await executeBounded(execute, requestFor({
+    harness,
+    kind: 'version',
+    probeId: `${harness}.version.v1`,
+    command: spec.command,
+    args: spec.versionArgs,
+    timeoutMs,
+    maxOutputBytes,
+  }), timeoutMs);
+  const versionExecution = normalizeExecution(versionResponse, maxOutputBytes);
+  if (!versionExecution.complete) {
+    return buildResult({
+      harness,
+      spec,
+      observedAt,
+      status: 'INCOMPLETE',
+      availability: 'UNAVAILABLE',
+      identity: null,
+      version: null,
+      capabilities: incompleteCapabilities(spec, versionExecution.reason),
+    });
+  }
+  const identity = versionExecution.executableIdentity;
+  const version = parseVersion(versionExecution.stdout || versionExecution.stderr, spec.versionPattern);
+  if (!EXECUTABLE_IDENTITY_PATTERN.test(identity || '')) {
+    return buildResult({
+      harness,
+      spec,
+      observedAt,
+      status: 'INCOMPLETE',
+      availability: 'UNAVAILABLE',
+      identity: null,
+      version,
+      capabilities: incompleteCapabilities(spec, 'EXECUTABLE_IDENTITY_UNAVAILABLE'),
+    });
+  }
+  if (!version) {
+    return buildResult({
+      harness,
+      spec,
+      observedAt,
+      status: 'INCOMPLETE',
+      availability: 'UNAVAILABLE',
+      identity,
+      version: null,
+      capabilities: incompleteCapabilities(spec, 'MALFORMED_VERSION'),
+    });
+  }
+
+  const capabilities = await probeCapabilities({
+    execute,
+    harness,
+    spec,
+    timeoutMs,
+    maxOutputBytes,
+    identity,
+  });
+
+  return buildResult({
+    harness,
+    spec,
+    observedAt,
+    status: capabilities.some((item) => item.status === 'INCOMPLETE') ? 'INCOMPLETE' : 'PASS',
+    availability: 'AVAILABLE',
+    identity,
+    version,
+    capabilities,
+  });
+}
+
+async function probeAllHarnesses(options) {
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new TypeError('probe options must be an object');
+  }
+  return Promise.all(HARNESS_IDS.map((harness) => probeHarness({ ...options, harness })));
+}
+
+module.exports = {
+  CAPABILITY_IDS,
+  DEFAULT_MAX_OUTPUT_BYTES,
+  DEFAULT_TIMEOUT_MS,
+  MAX_OUTPUT_BYTES,
+  MAX_TIMEOUT_MS,
+  HARNESS_IDS,
+  HARNESS_PROBE_SPECS,
+  PROBE_REVISION,
+  getHarnessProbeSpec,
+  probeAllHarnesses,
+  probeHarness,
+};

package/lib/capped-jsonl-log.js

@@ -0,0 +1,236 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * The local append-only JSONL sink shared by every Forge log that must survive
+ * without a database handle: the protected-state audit log and the subagent
+ * audit-evidence log. Kept in its own module so both writers get the same
+ * concurrency and cap behaviour instead of a second copy drifting from the first.
+ */
+
+const TRIM_LOCK_ATTEMPTS = 5;
+const TRIM_LOCK_RETRY_MS = 20;
+/**
+ * How many times the trim re-reads the log for records appended since its
+ * snapshot. Each pass copies less than the last, so a small bound is enough to
+ * drain a burst without letting a busy writer keep the rename waiting forever.
+ */
+const TRIM_DELTA_PASSES = 3;
+/**
+ * How many times the trim rewrites the log to get it under the cap. A rewrite
+ * that drained concurrent appends can still sit above it, and one more quiet
+ * pass settles that; the bound stops a relentless writer from pinning the lock.
+ */
+const NEWLINE_BYTE = 0x0a;
+/** The trim rewrite takes milliseconds, so an older lock outlived its process. */
+const TRIM_LOCK_STALE_MS = 5000;
+/**
+ * Another process is using the file. POSIX reports only EEXIST/EBUSY, but
+ * Windows answers EPERM/EACCES both for a lock whose delete is still pending and
+ * for a replace of a log some other writer holds open.
+ */
+const FILE_CONTENDED_CODES = new Set(['EEXIST', 'EPERM', 'EACCES', 'EBUSY']);
+
+function sleepSync(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function lockHeldSinceMs(lockPath) {
+	try {
+		return fs.lstatSync(lockPath).mtimeMs;
+	} catch (error) {
+		if (error.code === 'ENOENT') return null;
+		throw error;
+	}
+}
+
+function acquireTrimLock(lockPath) {
+	for (let attempt = 0; attempt < TRIM_LOCK_ATTEMPTS; attempt += 1) {
+		try {
+			return fs.openSync(lockPath, 'wx');
+		} catch (error) {
+			if (!FILE_CONTENDED_CODES.has(error.code)) throw error;
+
+			const heldSince = lockHeldSinceMs(lockPath);
+			if (heldSince !== null && Date.now() - heldSince > TRIM_LOCK_STALE_MS) {
+				try {
+					fs.unlinkSync(lockPath);
+				} catch {
+					// Another writer reclaimed it first; retry against theirs.
+				}
+				continue;
+			}
+
+			sleepSync(TRIM_LOCK_RETRY_MS);
+		}
+	}
+
+	return null;
+}
+
+function releaseTrimLock(handle, lockPath) {
+	try {
+		fs.closeSync(handle);
+	} catch {
+		// Already closed.
+	}
+	try {
+		fs.unlinkSync(lockPath);
+	} catch {
+		// Already reclaimed as stale.
+	}
+}
+
+/**
+ * Reads the log as whole records plus the byte offset they end at, so a later
+ * read can resume exactly where this one stopped. A trailing partial line is
+ * excluded from both: it belongs to an append still in flight, and cutting the
+ * offset at the last newline keeps the resume point on a record boundary.
+ */
+function snapshotJsonl(logPath) {
+	let raw;
+	try {
+		raw = fs.readFileSync(logPath);
+	} catch (error) {
+		if (error.code !== 'ENOENT') throw error;
+		return { lines: [], size: 0 };
+	}
+
+	const size = raw.lastIndexOf(NEWLINE_BYTE) + 1;
+	return { lines: raw.subarray(0, size).toString('utf8').split('\n').filter(Boolean), size };
+}
+
+/** The whole records appended past `offset`, or null when there are none yet. */
+function readAppendsSince(logPath, offset) {
+	let size;
+	try {
+		// Almost every trim runs with nobody appending, so answer from a stat alone
+		// and keep the extra work off the lock in the common case.
+		size = fs.statSync(logPath).size;
+	} catch (error) {
+		if (error.code === 'ENOENT') return null;
+		throw error;
+	}
+	if (size <= offset) return null;
+
+	let handle;
+	try {
+		handle = fs.openSync(logPath, 'r');
+	} catch (error) {
+		if (error.code === 'ENOENT') return null;
+		throw error;
+	}
+
+	try {
+		const buffer = Buffer.alloc(size - offset);
+		const read = fs.readSync(handle, buffer, 0, buffer.length, offset);
+		const end = buffer.subarray(0, read).lastIndexOf(NEWLINE_BYTE) + 1;
+		if (end === 0) return null;
+
+		const bytes = buffer.subarray(0, end);
+		return { bytes, records: bytes.toString('utf8').split('\n').filter(Boolean).length };
+	} finally {
+		fs.closeSync(handle);
+	}
+}
+
+/**
+ * One rewrite of the log down to its cap, returning the record count it left
+ * behind — or null when a contended rename made it give up. Records drained from
+ * concurrent appenders ride above the cap, so the caller has to check.
+ * Must be called with the trim lock held.
+ */
+function rewriteToCap(logPath, maxRecords, pendingLine = null) {
+	const snapshot = snapshotJsonl(logPath);
+	if (snapshot.lines.length < maxRecords && pendingLine !== null) {
+		fs.appendFileSync(logPath, `${pendingLine}\n`, 'utf8');
+		return snapshot.lines.length + 1;
+	}
+	if (snapshot.lines.length <= maxRecords && pendingLine === null) return snapshot.lines.length;
+
+	const candidates = pendingLine === null ? snapshot.lines : [...snapshot.lines, pendingLine];
+	const kept = candidates.slice(-maxRecords);
+	// Write-then-rename so a crash mid-trim cannot leave a torn log behind.
+	const tempPath = `${logPath}.${process.pid}.tmp`;
+	fs.writeFileSync(tempPath, `${kept.join('\n')}\n`, 'utf8');
+
+	// Appenders hold no lock, so records keep landing in the log this rename is
+	// about to replace. Copy them onto the temp file first — repeatedly, since
+	// the copy itself takes time a writer can append into. Nothing heavier goes
+	// between the last copy and the rename, which is what keeps the window small.
+	let offset = snapshot.size;
+	let drained = 0;
+	for (let pass = 0; pass < TRIM_DELTA_PASSES; pass += 1) {
+		const appended = readAppendsSince(logPath, offset);
+		if (appended === null) break;
+		fs.appendFileSync(tempPath, appended.bytes);
+		offset += appended.bytes.length;
+		drained += appended.records;
+	}
+	if (pendingLine !== null && drained > 0) {
+		const prepared = snapshotJsonl(tempPath).lines;
+		fs.writeFileSync(tempPath, `${prepared.slice(-maxRecords).join('\n')}\n`, 'utf8');
+	}
+
+	try {
+		fs.renameSync(tempPath, logPath);
+	} catch (error) {
+		// Another writer still has the log open for its append. Same answer as
+		// losing the lock race: drop this trim, the next writer will do it.
+		if (!FILE_CONTENDED_CODES.has(error.code)) throw error;
+		fs.rmSync(tempPath, { force: true });
+		return null;
+	}
+	return pendingLine === null ? kept.length + drained : Math.min(kept.length + drained, maxRecords);
+}
+
+function appendAtCap(logPath, recordLine, maxRecords) {
+	const snapshot = snapshotJsonl(logPath);
+
+	const lockPath = `${logPath}.lock`;
+	const lock = acquireTrimLock(lockPath);
+	// A held lock means another writer is already trimming. These logs are
+	// best-effort sinks on the hot path of a hook or a command, so skip and let
+	// the next writer past the cap trim instead of blocking the caller.
+	if (lock === null) {
+		fs.appendFileSync(logPath, `${recordLine}\n`, 'utf8');
+		return snapshot.lines.length + 1;
+	}
+
+	try {
+		const rewritten = rewriteToCap(logPath, maxRecords, recordLine);
+		if (rewritten === null) {
+			fs.appendFileSync(logPath, `${recordLine}\n`, 'utf8');
+			return snapshotJsonl(logPath).lines.length;
+		}
+		return rewritten;
+	} finally {
+		releaseTrimLock(lock, lockPath);
+	}
+}
+
+/**
+ * Below the cap, O_APPEND keeps each small record atomic. At the cap, the new
+ * record is prepared inside the locked replacement so failure cannot be
+ * reported after the authorization has already landed in the live log.
+ *
+ * That leaves one window, and the trim narrows rather than closes it: records
+ * appended after the trim's snapshot are drained onto the replacement file right
+ * before the rename, so only a record landing between the final drain and the
+ * rename syscall itself can still be lost. Closing it completely would mean
+ * locking every append, which these hot-path sinks do not pay for.
+ */
+function appendCappedJsonlRecord(logPath, record, maxRecords) {
+	fs.mkdirSync(path.dirname(logPath), { recursive: true });
+	const recordLine = JSON.stringify(record);
+	const snapshot = snapshotJsonl(logPath);
+	if (snapshot.lines.length < maxRecords) {
+		fs.appendFileSync(logPath, `${recordLine}\n`, 'utf8');
+		return snapshot.lines.length + 1;
+	}
+	return appendAtCap(logPath, recordLine, maxRecords);
+}
+
+module.exports = {
+	appendCappedJsonlRecord,
+};

package/lib/codex-skills.js

@@ -135,9 +135,9 @@ function resolveCodexRepoSkillsDir(projectRoot) {
  * @param {boolean} [params.clean=false] - Remove stale canonical-managed dirs first.
  * @returns {{targetSkillsDir: string, written: string[]}}
  */
-function populateCodexRepoSkills({ sourceRoot, projectRoot, clean = false }) {
+function populateCodexRepoSkills({ sourceRoot, projectRoot, clean = false, excludeRelativePaths }) {
   const targetSkillsDir = resolveCodexRepoSkillsDir(projectRoot);
-  const { written } = populateAgentSkills({ sourceRoot, targetSkillsDir, clean });
+  const { written } = populateAgentSkills({ sourceRoot, targetSkillsDir, clean, excludeRelativePaths });
   return { targetSkillsDir, written };
 }
 

package/lib/commands/_manifest.js

@@ -39,6 +39,7 @@ const commands = [
   { file: "explain.js", module: require("./explain") },
   { file: "export.js", module: require("./export") },
   { file: "gate.js", module: require("./gate") },
+  { file: "github.js", module: require("./github") },
   { file: "hooks.js", module: require("./hooks") },
   { file: "inbox.js", module: require("./inbox") },
   { file: "init.js", module: require("./init") },