@nuucognition/flint-cli 0.7.0-dev.4 → 0.7.0-dev.5

package/README.md

@@ -204,6 +204,7 @@ flint shard install --from-git NUU-Cognition/shard-plan#v0.4.0
 flint shard install --from-path ../shards/sketchpad
 flint shard install @nuucognition/tasks#demo-maker  # from a Flint on this machine
 flint shard update                                   # move the lock inside the range of each spec
+flint shard broadcast tasks --dry-run                # after a change to a source here: the Flints that install it from here
 flint shard versions notepad
 flint shard uninstall notepad
 ```

package/bin/flint-prod.js

@@ -22,6 +22,13 @@ import { shouldEnableOpenTuiFfi } from '../dist/open-tui-invocation.js';
 const args = process.argv.slice(2);
 const completionRequested = args[0] === '__complete';
 
+// `flint foundation` (Task 1080): the small Foundation entry runs before the host bundle and the stamp check, and exits.
+// A build with no such entry falls through to dist/index.js, which routes the command too.
+if (args[0] === 'foundation') {
+  const foundation = await import('../dist/foundation.js').catch(() => null);
+  if (foundation) await foundation.exitWithFoundation(args.slice(1));
+}
+
 if (!completionRequested) {
   const openTuiRequested = shouldEnableOpenTuiFfi({
     cli: 'flint',

package/bin/launch-flint.js

@@ -53,6 +53,14 @@ export async function launchFlint({ launcherPath }) {
   const srcEntry = join(packageRoot, 'src', `${entryName}.ts`);
   const distEntry = join(packageRoot, 'dist-dev', `${entryName}.js`);
 
+  // `flint foundation` (Task 1080): the small Foundation entry runs before the host bundle and the stamp check, and exits.
+  // A source run goes through src/index.ts, which routes the command too.
+  const foundationEntry = join(packageRoot, 'dist-dev', 'foundation.js');
+  if (args[0] === 'foundation' && !forceSource && existsSync(foundationEntry)) {
+    const { exitWithFoundation } = await import(foundationEntry);
+    await exitWithFoundation(args.slice(1));
+  }
+
   // NO SOURCE RUN FOR A DAEMON (incident of 2026-09-21). nclient sets
   // FLINT_REQUIRE_BUNDLE=1 for every one-shot. A source run is two processes,
   // about 300 MB, and tens of seconds; thirty of them at one time took three

package/bin/nuu.js

@@ -1,19 +1,41 @@
 #!/usr/bin/env node
-// The `nuu` command of one flint install (Task 1048, UX1; ruling 31). npm
-// links only the bins of the package that a person installs, so a dependency
-// alone does not put `nuu` on the PATH. This launcher runs the `nuu` bin of the
-// dependency @nuucognition/nuu-cli, as its package.json names it.
-import { readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
+// The `nuu` command of one flint install (Task 1048, UX1; ruling 31). The nuu
+// CLI is inside the flint bundle, as Blacksmith is (Task 1058): this launcher
+// runs dist/nuu.js, and no package @nuucognition/nuu-cli is installed.
+import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 
-const require = createRequire(import.meta.url);
-const manifestPath = require.resolve('@nuucognition/nuu-cli/package.json');
-const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-const bin = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.nuu;
-if (typeof bin !== 'string') {
-  process.stderr.write('✘ The package @nuucognition/nuu-cli names no nuu command.\n  Next: npm install -g @nuucognition/flint-cli\n');
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const entrypoint = join(__dirname, '..', 'dist', 'nuu.js');
+
+// `nuu foundation` (Task 1080): the Foundation entry of `flint foundation` runs before the nuu bundle and the stamp
+// check, and exits. A build with no such entry falls through to dist/nuu.js.
+const foundationEntry = join(__dirname, '..', 'dist', 'foundation.js');
+if (process.argv[2] === 'foundation' && existsSync(foundationEntry)) {
+  const { exitWithFoundation } = await import(pathToFileURL(foundationEntry).href);
+  await exitWithFoundation(process.argv.slice(3), 'nuu foundation');
+}
+
+if (!existsSync(entrypoint)) {
+  process.stderr.write(`✘ This flint install has no nuu bundle at ${entrypoint}.\n  Next: npm install -g @nuucognition/flint-cli\n`);
   process.exit(1);
 }
-await import(pathToFileURL(join(dirname(manifestPath), bin)).href);
+
+// In a checkout the stamp check applies as for flint-prod.js; in an installed
+// npm package cli-core is absent and the check is skipped.
+const { warnIfBuildStale } = await import('@nuucognition/cli-core/launch').catch(() => ({ warnIfBuildStale() {} }));
+warnIfBuildStale({ cli: 'nuu', distEntry: entrypoint, rebuildHint: 'Run: ndv build flint prod' });
+
+try {
+  const { enableCompileCache } = await import('node:module');
+  enableCompileCache?.();
+} catch {
+  /* uncached */
+}
+
+// This process is this launcher: the nclient daemon starts with it
+// (`nuu client start`), and every printed command names `nuu`.
+process.env.NUU_CLI_LAUNCHER = fileURLToPath(import.meta.url);
+process.env.NUU_CLI_ENTRYPOINT = entrypoint;
+await import(pathToFileURL(entrypoint).href);

package/dist/.build-stamp.json

@@ -1,7 +1,7 @@
 {
-  "sha": "44d93c57b5ce9e290c03306607c357aa10922ebd",
-  "tree": "cb7ccf1fa1065e82ce3ca3be3d3971e7026dc4c8",
-  "dirty": true,
-  "builtAt": "2026-09-28T11:20:43.042Z",
+  "sha": "4ac20c5428b62e1f2de74b6544fde152a2ab247c",
+  "tree": "4292f2915b1ceba3e73bbd8436575da2520d49a1",
+  "dirty": false,
+  "builtAt": "2026-09-29T23:40:46.440Z",
   "mode": "prod"
 }

package/dist/_flint/prompts/agentic/sweep-0.7.0.md

@@ -165,13 +165,7 @@ Obey these rules for the whole session. Only the operator can make an exception.
    - `(H)`, `(S)`, or `(P)` (headless): `flint orbh resume <id> "The Flint {{targetVersion}} sweep parked this session. Continue your work." -p "<Flint path>"`
    - For the `machine` scope, use `--at machine` in place of `-p "<Flint path>"`.
 5. Run `flint orbh list --all-scopes --print` again. Park each live session that woke.
-6. **Obsidian.** Ask the operator to quit Obsidian now, and wait for the answer. This is the only question of the sweep. Step l5 of the migration converts the Obsidian payload of a Flint only when its vault is closed, and a copy of an open vault can change while you copy it. Then list the open vaults:
-
-   ```
-   flint migrate machine --json | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{for(const r of JSON.parse(s).flints)if(r.obsidian.vault==="open")console.log(r.label)})'
-   ```
-
-   When a vault is still open, record it, and continue: the conversion of that Flint waits until a later `flint sync`.
+6. **Obsidian.** Ask nothing about Obsidian. Obsidian can stay open, also the vault of the Computer Flint, where this session runs. When the vault of a Flint is open and its NUU Flint plugin answers, step l5 and `flint sync` convert the legacy payload and then reload that vault. The reload stops each terminal tab of that vault that runs a process, and the step names each such tab. When no plugin answers, or when the command runs in a terminal tab of that vault, the conversion waits for a later `flint sync` (section 7).
 
 ## 4. Phase 3 — copy every Flint first
 
@@ -253,10 +247,10 @@ It has these sections, and nothing about other machines:
    - Synced: `yes`, `no: <reason>`, `-`
    - Committed: `yes <short id>` (add the checkpoint id when there is one), `no change`, `box: not committed`, `no repository`, `-`
    - Pushed: `yes`, `held (remote did not answer)`, `not pushed: <reason>`, `no upstream`, `-`
-   - Note: the `summary` line of a stop, the count of `shard-record/0.3` records, the next commands that the sync named, an open vault, the embedded repositories, the changed shard sources, the people whose commits the integration brought in (for information only), and each other fact.
+   - Note: the `summary` line of a stop, the count of `shard-record/0.3` records, the next commands that the sync named, a reload of Obsidian and the tabs that it stopped, a conversion that waits, the embedded repositories, the changed shard sources, the people whose commits the integration brought in (for information only), and each other fact.
 3. **Parked sessions.** One table with the columns Session, Flint, Title, and Resume (the command of phase 2, step 4). Also each session that was not parked, with the reason.
 4. **The backup folder.** The path, and how to put a copy back. To put the copy of one Flint back:
-   1. Quit Obsidian, and park the sessions of that Flint.
+   1. Close the vault of that Flint in Obsidian, and park the sessions of that Flint.
    2. Move the migrated folder into the backup folder, outside every box: `mv "<Flint path>" "{{backupFolder}}/<Copy> (migrated)"`.
    3. Copy the backup back: `{{copyCommand}} "{{backupFolder}}/<Copy>" "<Flint path>"`.
    4. A push stays on origin. The next `flint git sync` of the restored Flint brings the migration back from origin.
@@ -276,7 +270,7 @@ At the end, tell the operator the summary in the terminal: the count of Flints t
 | More than one unfinished run | The run refuses. Record it. Never run `flint migrate rollback` (rule 4). |
 | A shard gets a local address `@/shard/<slug>` | The run learns the owner of each repository from the registry. Record each local address in the note. |
 | `Exports/` keeps entries | Normal. Step s7 removes only proved bundles, and prints one line with the size of each kept entry. |
-| A vault is open | Step l5 waits, and the conversion waits for a later `flint sync`. Record "Obsidian waits". |
+| A vault is open | Step l5 converts the payload, and then reloads the vault through its NUU Flint plugin. The step names each terminal tab that the reload stopped. Record "Obsidian reloaded" and the tabs. With no live plugin, or with this session in a terminal tab of that vault, the conversion waits for a later `flint sync`: record "Obsidian waits". |
 | A changed Flint-owned file of the Obsidian payload | Normal. Step l5 saves it in the Obsidian backup store and replaces it. |
 | A changed personal file of the Obsidian payload (for example a snippet) | Step l5 stops, and names `flint obsidian repair --replace --dry-run`. The shared steps are complete: continue with the sync, the commit, and the push (phase 4, step 5). Record the file and the command for the operator. |
 | Git tracks files under `.orb` or `.orbh` | Step s2 warns, and step l3 copies the tracked session spools into the local space. Untrack nothing (rule 6). |