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

package/lib/commands/init.js

@@ -335,27 +335,40 @@ function renderDayOneConfigYaml({ profile, classification, harnessTargets, rails
   config.workflow.classification = { default: classification };
   config.layer1Rails = {
     confirmed: railsConfirmed,
+    // The immutable Layer 1 floor: locked rails that cannot be toggled off.
     rails: [
-      'tdd_intent',
       'secret_scan',
       'branch_protection',
       'signed_commits',
       'schema_integrity',
     ],
+    // tdd_intent is a strong DEFAULT rail, not an immutable L1 floor: it is unlocked
+    // (locked:false) and honestly toggleable via `forge gate disable rail.tdd_intent`
+    // (the minimal profile ships it off). Listed separately so this display never
+    // implies it is a non-negotiable Layer 1 rail (issue eda6d866).
+    toggleableRails: ['tdd_intent'],
   };
   config.adapters = config.adapters || {};
   config.adapters.harness = {
     enabled: harnessTargets.length > 0,
     targets: harnessTargets,
   };
-  config.protectedPaths = [
-    ...new Set([
-      ...(Array.isArray(config.protectedPaths) ? config.protectedPaths : []),
-      '.forge/config.yaml',
-      '.forge/patch.md',
-      '.forge/protected-paths.yaml',
-    ]),
-  ];
+  // The adoption profile is authoritative for whether protected-path enforcement runs
+  // at all. When it resolves EMPTY (the `minimal` profile = zero active enforcement),
+  // the protected-path guard must stay genuinely inert — do NOT re-add the day-one
+  // paths, or `init --minimal` would silently reactivate the guard the profile just
+  // disabled (issue eda6d866). Standard/full keep their profile paths + the additions.
+  const profilePaths = Array.isArray(config.protectedPaths) ? config.protectedPaths : [];
+  config.protectedPaths = profilePaths.length === 0
+    ? []
+    : [
+        ...new Set([
+          ...profilePaths,
+          '.forge/config.yaml',
+          '.forge/patch.md',
+          '.forge/protected-paths.yaml',
+        ]),
+      ];
   return YAML.stringify(config);
 }
 
@@ -543,24 +556,17 @@ async function handler(args, flags, projectRoot = process.cwd(), deps = {}) {
   }
 
   // Close the onboarding loop that a bare `forge init` used to leave open:
-  //  1. install git hooks so stage commands are not HOOKS_NOT_ACTIVE-blocked, and
-  //  2. import any existing Beads store into the Kernel.
-  // Both reuse setup's real implementations (overridable via deps for tests) and
-  // degrade to a warning rather than failing init.
+  // install git hooks so stage commands are not HOOKS_NOT_ACTIVE-blocked. Reuses
+  // setup's real implementation (overridable via deps for tests) and degrades to a
+  // warning rather than failing init. Beads → Kernel transfer is NOT done here: it
+  // is explicit-only via `forge migrate --from beads` (a7e1443c), never implicit.
   const installHooks = deps.installHooks
     || ((root) => require('./setup').ensureGitHooksInstalled(root));
-  const autoMigrateBeads = deps.autoMigrateBeads
-    || ((root) => require('./migrate').autoMigrateBeadsIfPresent(root));
   try {
     await installHooks(projectRoot);
   } catch (err) {
     console.warn(`Warning: git hook installation skipped: ${err.message}`);
   }
-  try {
-    await autoMigrateBeads(projectRoot);
-  } catch (err) {
-    console.warn(`Warning: Beads → Kernel migration skipped: ${err.message}`);
-  }
 
   console.log(`Initialized Forge adoption profile '${profile}' at .forge/`);
   console.log(`Classification: ${choices.classification}`);

package/lib/commands/memory.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const remember = require('./remember');
+const recall = require('./recall');
+const insights = require('./insights');
+const { stripGlobalFlags } = require('../global-flags');
+
+// One memorable surface over the EXISTING memory commands (kernel issue 25362344): every
+// subcommand delegates to the standalone remember/recall/insights handlers — the same
+// kernel-backed store, not a reimplementation. The standalone `forge remember`/`forge
+// recall`/`forge insights` commands remain registered as back-compat aliases, so nothing
+// that already calls them breaks.
+const SUBCOMMANDS = {
+  add: {
+    handler: remember.handler,
+    summary: 'Persist a memory note (= forge remember; supports --type + What/Why/Where/Learned)',
+  },
+  recall: {
+    handler: recall.handler,
+    summary: 'Retrieve memory notes, newest first (= forge recall; filter with --type)',
+  },
+  search: {
+    // Search IS recall with a query — recall runs a BM25 token-AND search when a query is
+    // present, so the same handler serves both without a second code path.
+    handler: recall.handler,
+    summary: 'Search memory notes by query (recall with a query; filter with --type)',
+  },
+  insights: {
+    handler: insights.handler,
+    summary: 'Detect recurring evidence patterns and suggest follow-ups (= forge insights)',
+  },
+};
+
+const usage = 'Usage: forge memory <add|recall|search|insights> [args]';
+
+function renderHelp() {
+  const width = Math.max(...Object.keys(SUBCOMMANDS).map(name => name.length));
+  const lines = [
+    usage,
+    '',
+    'Subcommands:',
+    ...Object.entries(SUBCOMMANDS).map(
+      ([name, { summary }]) => `  ${name.padEnd(width)}  ${summary}`
+    ),
+    '',
+    'Back-compat: forge remember / forge recall / forge insights remain available as aliases.',
+  ];
+  return lines.join('\n');
+}
+
+async function handler(args, flags, projectRoot, opts) {
+  // The subcommand is the first positional token; global flags (e.g. `-p <dir>`) are stripped
+  // first so they never masquerade as the subcommand.
+  const positional = stripGlobalFlags(args).find(arg => !arg.startsWith('-'));
+
+  if (!positional || positional === 'help' || args.includes('--help') || args.includes('-h')) {
+    return { success: true, output: renderHelp() };
+  }
+
+  const sub = SUBCOMMANDS[positional];
+  if (!sub) {
+    return {
+      success: false,
+      error: `Unknown memory subcommand: ${positional}\n\n${renderHelp()}`,
+    };
+  }
+
+  // Forward everything EXCEPT the consumed subcommand token to the delegate, preserving any
+  // global flags the delegate re-parses (e.g. `-p <dir>`, `--all`).
+  const idx = args.indexOf(positional);
+  const childArgs = idx >= 0 ? [...args.slice(0, idx), ...args.slice(idx + 1)] : args;
+  return sub.handler(childArgs, flags, projectRoot, opts);
+}
+
+module.exports = {
+  name: 'memory',
+  description:
+    'Unified memory surface: forge memory add|recall|search|insights (wraps remember/recall/insights)',
+  usage,
+  handler,
+};

package/lib/commands/migrate.js

@@ -301,171 +301,10 @@ async function runBeadsMigration(options, projectRoot, opts) {
   }
 }
 
-/**
- * Detect a jsonl-backed Beads store under `<projectRoot>/.beads`. Returns the
- * directory path when it holds *.jsonl sidecars, else null.
- *
- * Onboarding (forge setup/init) uses this to decide whether to auto-migrate.
- * It deliberately never falls back to `bd export` (a Dolt-only store with no
- * jsonl returns null), so setup stays bd-free even when Dolt is down.
- */
-function detectBeadsJsonlSource(projectRoot, deps = {}) {
-  const fsImpl = deps.fs || fs;
-  const beadsDir = path.join(projectRoot || process.cwd(), '.beads');
-  return fsImpl.existsSync(beadsDir) && directoryHasJsonl(beadsDir, fsImpl)
-    ? beadsDir
-    : null;
-}
-
-/**
- * Idempotently import an existing jsonl-backed Beads store into the Kernel as
- * part of onboarding. Reuses the exact `forge migrate --from beads` spine, so
- * gaps are surfaced honestly and a second run inserts nothing.
- *
- * No-op (`{ migrated: false, reason: 'no-beads-jsonl' }`) when there is no jsonl
- * `.beads/` present. Never requires the `bd` binary.
- *
- * @param {string} projectRoot
- * @param {object} [opts] - Passed through to runBeadsMigration (_broker/_now/_fs seams).
- * @returns {Promise<{ migrated: boolean, reason?: string, result?: object }>}
- */
-async function autoMigrateBeadsIfPresent(projectRoot, opts = {}) {
-  if (!detectBeadsJsonlSource(projectRoot, { fs: opts._fs })) {
-    return { migrated: false, reason: 'no-beads-jsonl' };
-  }
-  const result = await runBeadsMigration({ from: 'beads' }, projectRoot, opts);
-  return { migrated: result.success === true, result };
-}
-
-const BEADS_MIGRATE_NUDGE =
-  'Forge could not import your Beads issues into the Kernel automatically. '
-  + 'Run `forge migrate --from beads` to import them.';
-
-// The "already imported" marker lives as a row in the broker's kernel_migrations
-// ledger (created unconditionally by broker.initialize()), NOT as a file beside the
-// DB. Keeping it INSIDE the kernel DB means a DB reset drops the marker and the import
-// self-heals; a file sentinel would survive the reset and leave issues dark forever.
-// The id uses underscores so it passes the ledger charset /^[0-9a-z_]+$/i and stays
-// clear of the tokens the D20 retirement audit counts (see release-readiness.js).
-const IMPORT_MARKER_TABLE = 'kernel_migrations';
-const IMPORT_MARKER_ID = 'data_import_beads_jsonl';
-
-// Read/record the import marker via the DRIVER (the broker exposes no raw SQL). Both
-// calls are param-less (raw SQL + config); the id is a hardcoded constant and appliedAt
-// is an ISO string, so interpolation is injection-safe — mirrors broker.recordMigrationSql.
-async function importMarkerPresent(driver, config) {
-  if (!driver || typeof driver.queryAll !== 'function') {
-    return false;
-  }
-  try {
-    const rows = await driver.queryAll(
-      `SELECT 1 FROM ${IMPORT_MARKER_TABLE} WHERE id = '${IMPORT_MARKER_ID}' LIMIT 1;`,
-      config,
-    );
-    return Array.isArray(rows) && rows.length > 0;
-  } catch {
-    // Ledger table absent / driver unavailable → treat as not-yet-imported.
-    return false;
-  }
-}
-
-async function recordImportMarker(driver, config, appliedAt) {
-  if (!driver || typeof driver.exec !== 'function') {
-    return;
-  }
-  try {
-    await driver.exec(
-      `INSERT OR IGNORE INTO ${IMPORT_MARKER_TABLE} (id, applied_at) VALUES ('${IMPORT_MARKER_ID}', '${appliedAt}');`,
-      config,
-    );
-  } catch {
-    // Best-effort marker; never break the command we ride on.
-  }
-}
-
-/**
- * First-use safety net for the kernel default backend. Onboarding auto-migrate runs
- * only from `forge setup`/`init`; an existing repo whose user merely upgrades forge
- * reads an EMPTY kernel on the first issue command, so their existing Beads issues
- * appear to vanish. This imports them ONCE — gated by an in-DB marker row in the
- * kernel_migrations ledger, so the gate shares the DB lifecycle and a DB reset
- * self-heals — idempotently, announcing on stderr only so `--json` stdout stays a pure
- * contract. NEVER throws: the safety net must never break the command it rides on.
- *
- * Only a jsonl-backed store is auto-imported (the migration binary is never shelled).
- * A store with no jsonl export is skipped silently. The marker is SUCCESS-ONLY: a
- * failed import records nothing and is retried (with a nudge) on the next kernel
- * command, so transient failures and DB resets self-heal. Imported issues land in the
- * read model directly and arrive UNCLAIMED — they surface via `forge issue ready`.
- *
- * @param {object} params
- * @param {string} params.projectRoot
- * @param {string} params.databasePath - kernel DB path (used for the driver config).
- * @param {object} params.broker - an initialized kernel broker to import through.
- * @param {object} params.driver - kernel driver, for the ledger marker read/write.
- * @param {object} [deps] - { fs, warn, now, driver, _fs } seams for tests.
- * @returns {Promise<{action:'migrated'|'nudge'|'skip', reason?:string, inserted?:number}>}
- */
-async function autoMigrateBeadsAtRuntime({ projectRoot, databasePath, broker, driver } = {}, deps = {}) {
-  const fsImpl = deps.fs || fs;
-  const warn = deps.warn || ((msg) => process.stderr.write(`${msg}\n`));
-  const appliedAt = deps.now || new Date().toISOString();
-  const markerDriver = deps.driver || driver;
-  const markerConfig = databasePath ? { databasePath } : {};
-  try {
-    if (!databasePath) {
-      return { action: 'skip', reason: 'no-db-path' };
-    }
-
-    // One-time gate: the import already ran on THIS kernel DB (the marker dies with the
-    // DB, so deleting kernel.sqlite to reset correctly re-triggers the import).
-    if (await importMarkerPresent(markerDriver, markerConfig)) {
-      return { action: 'skip', reason: 'already-imported' };
-    }
-
-    // Only a jsonl export can be imported automatically; anything else is skipped
-    // silently (an empty or export-less store must never trigger a false nudge).
-    if (!detectBeadsJsonlSource(projectRoot, { fs: fsImpl })) {
-      return { action: 'skip', reason: 'no-jsonl' };
-    }
-
-    // Import (idempotent) through the already-initialized broker.
-    let outcome;
-    try {
-      outcome = await autoMigrateBeadsIfPresent(projectRoot, { _broker: broker, _now: deps.now, _fs: deps._fs });
-    } catch (err) {
-      outcome = { migrated: false, result: { success: false, error: err.message } };
-    }
-
-    if (outcome.migrated) {
-      const inserted = outcome.result?.imported?.issues?.inserted ?? 0;
-      const skipped = outcome.result?.imported?.issues?.skipped ?? 0;
-      // Record the marker LAST so a concurrent first run is a benign idempotent skip.
-      await recordImportMarker(markerDriver, markerConfig, appliedAt);
-      if (inserted > 0) {
-        warn(`Forge: imported ${inserted} Beads issue(s) into the Kernel — your issues are here, not lost.`);
-      }
-      return { action: 'migrated', inserted, skipped };
-    }
-
-    // Success-only marker: a failed import records nothing and re-nudges next run,
-    // so a transient failure self-heals once the underlying problem is resolved.
-    const error = outcome.result?.error || outcome.reason || 'unknown error';
-    warn(BEADS_MIGRATE_NUDGE);
-    return { action: 'nudge', reason: 'migrate-failed', error };
-  } catch (err) {
-    // Absolutely never break the command we ride on.
-    return { action: 'skip', reason: 'error', error: err.message };
-  }
-}
-
 module.exports = {
   name: 'migrate',
   description: 'Migrate a Beads issue store into the Forge Kernel with --from beads, '
     + 'or preview the v2→v3 migration (preview only — --dry-run required; applying it is not yet available)',
-  detectBeadsJsonlSource,
-  autoMigrateBeadsIfPresent,
-  autoMigrateBeadsAtRuntime,
   usage: 'forge migrate --from beads [--dry-run] [--source <dir>] [--json]',
   flags: {
     '--from <source>': 'Migration source. Use "beads" to import a Beads issue store into the Kernel.',