@aitne-sh/aitne 0.1.7 → 0.1.9

package/agent-assets/templates/{rules → policies}/redaction.md

@@ -22,7 +22,7 @@ redaction is performed in code by `packages/shared/src/secret-redaction.ts`.
 ## Context-specific (journal export)
 
 When exporting `daily/*.md` to an external vault (B-005), additional
-user-defined rules in `rules/journal-export.md` are applied on top.
+user-defined rules in `policies/journal-export.md` are applied on top.
 
 ## Appearance in logs
 

package/agent-assets/templates/{routines → policies/routines}/_index.md

@@ -17,4 +17,4 @@ I've added later via DM). All checks are treated equally.
 | `evening.md` | evening | `routine.evening_review` |
 | `weekly.md` | Friday | `routine.weekly_review` |
 | `monthly.md` | month-end | `routine.monthly_review` |
-| custom/<slug>.md | user-defined cron in `routines/custom/` | `routine.custom.<slug>` |
+| custom/<slug>.md | user-defined cron in `policies/routines/custom/` | `routine.custom.<slug>` |

package/agent-assets/templates/{routines → policies/routines}/evening.md

@@ -10,7 +10,7 @@ template_version: 1
 ## Checks
 
 ### Today → Handoff
-- **Action**: scan `today.md` for open items and summarize them into
+- **Action**: scan `state/today.md` for open items and summarize them into
   `## Handoff` so tomorrow's morning routine can pick them up
 
 ### Tomorrow preview
@@ -18,5 +18,5 @@ template_version: 1
   deadlines into `## Handoff`
 
 ### Journal tail
-- **Action**: append a 1–2 sentence note to `agent/journal.md` describing
+- **Action**: append a 1–2 sentence note to `journal/agent.md` describing
   anything surprising the agent observed today

package/agent-assets/templates/{routines → policies/routines}/hourly.md

@@ -21,7 +21,7 @@ skipping any whose preconditions are not met.
 
 ### Upcoming schedule
 - **Precondition**: always
-- **Action**: scan `today.md` `## Agent Plan` for items in the next 60
+- **Action**: scan `state/today.md` `## Agent Plan` for items in the next 60
   min; ensure each has a `scheduled.task` row.
 
 ## Skip conditions (applied before any check)

package/agent-assets/templates/{routines → policies/routines}/monthly.md

@@ -17,9 +17,9 @@ Fires on the last calendar day of the month. Output target:
   `daily/*.md` items
 
 ### Roadmap delta
-- **Action**: compare current `roadmap.md` against the month's progress;
+- **Action**: compare current `plans/roadmap.md` against the month's progress;
   highlight completed + delayed items
 
 ### Habit + health snapshot
-- **Action**: if the user logged health/habit data in `user/personal.md`,
+- **Action**: if the user logged health/habit data in `identity/personal.md`,
   surface month-over-month changes (opt-in only)

package/bin/aitne.mjs

@@ -8,6 +8,15 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { ensureBuild } from "../scripts/run-node.mjs";
 import { fetchHttpOk, openBrowser } from "../scripts/browser.mjs";
+// Port defaults live in this plain-ESM module (NOT @aitne/shared, per the
+// pre-build constraint noted below). scripts/lib/ ships in the published
+// `files` list, so this import works in global installs too.
+import {
+  DEFAULT_API_PORT,
+  DEFAULT_DASHBOARD_PORT,
+  resolveApiPort,
+  resolveDashboardPort,
+} from "../scripts/lib/ports.mjs";
 
 const IS_WINDOWS = process.platform === "win32";
 
@@ -55,8 +64,8 @@ const DAEMON_PID_FILE = path.join(PIDS_DIR, "daemon.pid");
 const DASHBOARD_PID_FILE = path.join(PIDS_DIR, "dashboard.pid");
 const DAEMON_LOG_FILE = path.join(DATA_DIR, "logs", "daemon.log");
 const DASHBOARD_LOG_FILE = path.join(DATA_DIR, "logs", "dashboard.log");
-const DAEMON_PORT = parseInt(process.env.PA_API_PORT || "8321", 10);
-const DASHBOARD_PORT = parseInt(process.env.PA_DASHBOARD_PORT || "3000", 10);
+const DAEMON_PORT = resolveApiPort();
+const DASHBOARD_PORT = resolveDashboardPort();
 
 const VERSION = JSON.parse(
   fs.readFileSync(path.join(PROJECT_ROOT, "package.json"), "utf8"),
@@ -989,6 +998,11 @@ Operations:
   open                              Open dashboard root in browser
   doctor                            Diagnose install (Node, ports, keychain, CLIs, …)
   audit [--since <dur>] [--type X]  Show agent action log (filterable)
+  run-now <job>                     Fire a daemon-internal maintenance job
+                                    on demand (e.g. roadmap_maintenance)
+  verify [target]                   Run post-launch verification for a
+                                    shipped design surface (e.g.
+                                    evening-review-slimdown)
   version                           Print version + Node + install path
   update                            Print npm command to upgrade
   uninstall                         Stop, then offer to wipe ${path.basename(DATA_DIR) || "data dir"}
@@ -999,8 +1013,8 @@ Options:
 
 Environment:
   PA_DATA_DIR                       Data directory (default: ~/.personal-agent)
-  PA_API_PORT                       Daemon port (default: 8321)
-  PA_DASHBOARD_PORT                 Dashboard port (default: 3000)
+  PA_API_PORT                       Daemon port (default: ${DEFAULT_API_PORT})
+  PA_DASHBOARD_PORT                 Dashboard port (default: ${DEFAULT_DASHBOARD_PORT})
 
 Examples:
   aitne start                       Launch in background
@@ -1016,7 +1030,7 @@ Run 'aitne help <command>' for detailed usage of a single command.`);
 // Used by `aitne help <cmd>` to dispatch into the module rather than duplicating
 // usage strings in cmdHelp() above.
 const PER_COMMAND_HELP = new Set([
-  "doctor", "audit", "setup", "open", "version", "update", "uninstall",
+  "doctor", "audit", "setup", "open", "version", "update", "uninstall", "run-now", "verify",
 ]);
 
 /**
@@ -1069,6 +1083,8 @@ switch (subcommand) {
   case "open":      await runExternalCommand("open", subArgs); break;
   case "doctor":    await runExternalCommand("doctor", subArgs); break;
   case "audit":     await runExternalCommand("audit", subArgs); break;
+  case "run-now":   await runExternalCommand("run-now", subArgs); break;
+  case "verify":    await runExternalCommand("verify", subArgs); break;
 
   // version / -v / --version all dispatch identically — passing subArgs
   // through so `aitne --version --json` yields the same output as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aitne-sh/aitne",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Aitne — a local-first, proactive personal AI agent. A long-running TypeScript daemon is the nervous system; Claude Code (or Codex / Gemini CLI) is the brain. All persistent memory lives in local Markdown files.",
   "keywords": [
     "ai",
@@ -43,9 +43,9 @@
     "README.md"
   ],
   "dependencies": {
-    "@aitne/daemon": "0.1.7",
-    "@aitne/dashboard": "0.1.7",
-    "@aitne/shared": "0.1.7"
+    "@aitne/daemon": "0.1.9",
+    "@aitne/dashboard": "0.1.9",
+    "@aitne/shared": "0.1.9"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^8.58.1",
@@ -75,6 +75,7 @@
     "test": "node scripts/check-redaction-coverage.mjs && vitest run --coverage",
     "test:watch": "vitest",
     "check:redaction": "node scripts/check-redaction-coverage.mjs",
+    "check:vault-paths": "node scripts/check-vault-path-drift.mjs",
     "lint": "turbo run lint",
     "typecheck:tests": "turbo run typecheck:tests",
     "clean": "turbo run clean && node scripts/rm-paths.mjs node_modules .buildstamp"

package/scripts/commands/doctor.mjs

@@ -37,6 +37,8 @@ Exit code:
     await checkPort("Dashboard port", ctx.DASHBOARD_PORT, ctx.DASHBOARD_PID_FILE, ctx.helpers.getRunningPid),
     await checkSecretStore(ctx),
     await checkBackendCli(),
+    await checkProcessProbe(),
+    await checkBrowserOpener(ctx.DASHBOARD_PORT),
     await checkDataDirWritable(ctx.DATA_DIR),
     await checkBetterSqlite3(ctx.PROJECT_ROOT),
     await checkAgentAssets(ctx.PROJECT_ROOT),
@@ -125,8 +127,8 @@ async function checkPort(label, port, pidFile, getRunningPid) {
     label,
     detail: `${port} in use by another process`,
     hint: label.startsWith("Daemon")
-      ? `Set PA_API_PORT to an open port (e.g. PA_API_PORT=8322 aitne start), or stop the conflicting process.`
-      : `Set PA_DASHBOARD_PORT to an open port (e.g. PA_DASHBOARD_PORT=3001 aitne start), or stop the conflicting process.`,
+      ? `Set PA_API_PORT to an open port (e.g. PA_API_PORT=8331 aitne start), or stop the conflicting process.`
+      : `Set PA_DASHBOARD_PORT to an open port (e.g. PA_DASHBOARD_PORT=8333 aitne start), or stop the conflicting process.`,
   };
 }
 
@@ -180,11 +182,17 @@ async function checkSecretStore(ctx) {
     }
   }
   if (platform === "win32") {
-    const psBinary = whichSync("powershell.exe") ? "powershell.exe" : "pwsh.exe";
+    // Match the factory's terminal fallback (secret-client-factory.ts:37-41): prefer
+    // in-box powershell.exe, else pwsh.exe, else default to powershell.exe — the exact
+    // binary the daemon will exec — so a both-missing FAIL names the right binary.
+    const psBinary = whichSync("powershell.exe") ? "powershell.exe" : (whichSync("pwsh.exe") ? "pwsh.exe" : "powershell.exe");
     try {
+      // Mirror WindowsDpapiSecretClient's real encrypt path: ConvertTo/From-SecureString
+      // (no -Key => DPAPI). Works on both powershell.exe (5.1) and pwsh.exe (7+); the prior
+      // [ProtectedData] type check false-fails on PowerShell-Core-only hosts that work fine.
       execFileSync(psBinary, [
-        "-NoProfile", "-Command",
-        "[System.Security.Cryptography.ProtectedData] | Out-Null; exit 0",
+        "-NoProfile", "-NonInteractive", "-Command",
+        "$s = ConvertTo-SecureString 'probe' -AsPlainText -Force; $e = ConvertFrom-SecureString $s; if (-not $e) { exit 1 }; exit 0",
       ], { stdio: "pipe", timeout: 5000 });
       return { status: "pass", label: "Secret store", detail: `Windows DPAPI via ${psBinary} reachable` };
     } catch (err) {
@@ -221,6 +229,56 @@ async function checkBackendCli() {
   };
 }
 
+/**
+ * Process-listing primitive — `pgrep` on POSIX, `tasklist` on Windows. The
+ * Obsidian observer uses this to ask "is the desktop app currently open?"
+ * before treating the vault as live (services/obsidian.ts). Warn (not fail)
+ * because every other observer keeps working without it.
+ */
+async function checkProcessProbe() {
+  const isWin = process.platform === "win32";
+  const tool = isWin ? "tasklist" : "pgrep";
+  if (whichSync(tool)) {
+    return { status: "pass", label: "Process probe", detail: `${tool} on PATH` };
+  }
+  return {
+    status: "warn",
+    label: "Process probe",
+    detail: `${tool} not on PATH`,
+    hint: isWin
+      ? "tasklist ships with Windows — check that %SystemRoot%\\System32 is on PATH."
+      : process.platform === "linux"
+        ? "apt install procps  · or equivalent for your distro."
+        : "pgrep ships with macOS in-box; check $PATH.",
+  };
+}
+
+/**
+ * Browser opener used by `aitne open` and the auto-open after `aitne start`.
+ * darwin → `open`, win32 → `cmd` (hosts the `start` builtin), linux → `xdg-open`.
+ * Warn-only: nothing in the daemon depends on this; users can navigate to
+ * the dashboard URL by hand if missing.
+ */
+async function checkBrowserOpener(dashboardPort) {
+  const platform = process.platform;
+  const tool =
+    platform === "darwin" ? "open"
+      : platform === "win32" ? "cmd"
+        : "xdg-open";
+  if (whichSync(tool)) {
+    return { status: "pass", label: "Browser opener", detail: `${tool} on PATH` };
+  }
+  return {
+    status: "warn",
+    label: "Browser opener",
+    detail: `${tool} not on PATH`,
+    hint:
+      platform === "linux"
+        ? `apt install xdg-utils  · or open http://localhost:${dashboardPort} manually after \`aitne start\`.`
+        : "Auto-open is a convenience; the dashboard URL works in any browser.",
+  };
+}
+
 async function checkDataDirWritable(dataDir) {
   try {
     fs.mkdirSync(dataDir, { recursive: true });

package/scripts/commands/run-now.mjs

@@ -0,0 +1,187 @@
+/**
+ * `aitne run-now <job>` — fire a daemon-internal maintenance job on
+ * demand.
+ *
+ * Currently supported jobs:
+ *   - `roadmap_maintenance` — mechanical roadmap.md maintenance pass
+ *     (substeps 2a / 2b / 2d of the legacy `routine.evening_review`
+ *     Step 2). Same code path the 17:45 cron callback fires. See
+ *     `docs/design/appendices/evening-review-slimdown.md` §2.2.
+ *
+ * Implementation:
+ *   - Reads the daemon's apiToken from the OS secret store (macOS
+ *     Keychain, Windows DPAPI, Linux libsecret, or the encrypted file
+ *     fallback) via the shared cross-platform reader — the same entry
+ *     the dashboard proxy uses. Bearer-auth required because
+ *     `POST /api/agent/run-now/*` routes are Approve-tier in the
+ *     `risk-classifier`.
+ *   - POSTs to `http://127.0.0.1:<PA_API_PORT>/api/agent/run-now/<job>`.
+ *   - Renders the structured `result` payload as a compact summary
+ *     plus the full JSON on `--json`.
+ *
+ * Exit codes:
+ *   - 0  job completed (including idempotent / no-op runs)
+ *   - 2  validation / argument error
+ *   - 3  daemon not running, not reachable, or 5xx
+ *   - 4  result.status === "failed" — the job reported errors[]
+ */
+import { readApiToken } from "../lib/read-api-token.mjs";
+
+const SUPPORTED_JOBS = new Set(["roadmap_maintenance"]);
+
+const JOB_ENDPOINTS = {
+  roadmap_maintenance: "/api/agent/run-now/roadmap-maintenance",
+};
+
+export async function run(args, ctx) {
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    return;
+  }
+  const opts = parseArgs(args);
+  if (!opts.job) {
+    process.stderr.write("Job is required.\n");
+    process.stderr.write("Available jobs: " + [...SUPPORTED_JOBS].join(", ") + "\n");
+    process.stderr.write("Run `aitne help run-now` for usage.\n");
+    process.exit(2);
+  }
+
+  if (!SUPPORTED_JOBS.has(opts.job)) {
+    process.stderr.write(`Unknown job: ${opts.job}\n`);
+    process.stderr.write("Available jobs: " + [...SUPPORTED_JOBS].join(", ") + "\n");
+    process.exit(2);
+  }
+
+  const token = readApiToken();
+  if (!token) {
+    process.stderr.write(
+      "Failed to read the daemon API token from the OS secret store.\n" +
+        "Is the daemon initialized? Run `aitne start` once first.\n",
+    );
+    process.exit(3);
+  }
+
+  const endpoint = JOB_ENDPOINTS[opts.job];
+  const url = `http://127.0.0.1:${ctx.DAEMON_PORT}${endpoint}`;
+
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({}),
+    });
+  } catch (err) {
+    process.stderr.write(`Failed to reach the daemon at ${url}: ${err.message}\n`);
+    process.stderr.write("Is the daemon running? Try `aitne status`.\n");
+    process.exit(3);
+  }
+
+  const text = await res.text();
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = { raw: text };
+  }
+
+  if (!res.ok) {
+    process.stderr.write(
+      `POST ${endpoint} → ${res.status}: ${body.error ?? "unknown"}\n`,
+    );
+    if (body.message) process.stderr.write(`${body.message}\n`);
+    process.exit(res.status >= 500 ? 3 : 2);
+  }
+
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(body, null, 2) + "\n");
+  } else {
+    printSummary(opts.job, body.result ?? body);
+  }
+
+  const status = body?.result?.status;
+  if (status === "failed") process.exit(4);
+}
+
+function parseArgs(args) {
+  const opts = { job: null, json: false };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--json") {
+      opts.json = true;
+      continue;
+    }
+    if (a.startsWith("-")) {
+      process.stderr.write(`Unknown flag: ${a}\n`);
+      process.exit(2);
+    }
+    if (opts.job) {
+      process.stderr.write(`Unexpected positional argument: ${a}\n`);
+      process.exit(2);
+    }
+    opts.job = a;
+  }
+  return opts;
+}
+
+function printSummary(job, result) {
+  if (job === "roadmap_maintenance") {
+    if (!result || typeof result !== "object") {
+      process.stdout.write("(no result payload)\n");
+      return;
+    }
+    const status = result.status ?? "unknown";
+    const lines = [
+      `status:           ${status}`,
+      `status_synced:    ${result.statusSynced ?? 0}`,
+      `swept:            ${result.swept ?? 0}`,
+      `stale_marked:     ${result.staleMarked ?? 0}`,
+    ];
+    if (result.skipReason) lines.push(`skip_reason:      ${result.skipReason}`);
+    if (Array.isArray(result.errors) && result.errors.length > 0) {
+      lines.push(`errors:           ${result.errors.length}`);
+      for (const err of result.errors) {
+        lines.push(`  - ${err.step}: ${err.message}`);
+      }
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+    return;
+  }
+  process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+}
+
+function printHelp() {
+  process.stdout.write(`Usage: aitne run-now <job> [--json]
+
+Fire a daemon-internal maintenance job on demand. Uses the same code
+path the cron schedule fires — useful for parallel-verification
+rollouts and operator debugging.
+
+Jobs:
+  roadmap_maintenance   Run the mechanical roadmap.md maintenance pass
+                        (substeps 2a / 2b / 2d). Acquires roadmap write
+                        lock, syncs Scheduled: statuses, sweeps aged
+                        Agent Action Plan entries, and applies
+                        Long-term Plans stale markers. Emits an
+                        \`agent_actions\` audit row with
+                        action_type='roadmap_mechanical_maintenance'
+                        and appends a line to agent/journal.md.
+
+Flags:
+  --json    Emit the full JSON result instead of the summary.
+  -h, --help  Print this message.
+
+Exit codes:
+  0   completed (success / skipped)
+  2   argument / validation error
+  3   daemon unreachable or 5xx
+  4   the job ran but reported errors[]
+
+Examples:
+  aitne run-now roadmap_maintenance
+  aitne run-now roadmap_maintenance --json
+`);
+}