muse-crew 0.8.0 → 0.9.0

package/lib/crew-api.js

@@ -54,6 +54,16 @@ function validateVisualProtocol(value) {
   throw usageError("visual_protocol must be true, false, or null.");
 }
 
+// environment_type validation: 'artifact' | 'terminal' | null. undefined
+// means "not provided" (create: defaults to null; update: leaves the field
+// alone). null is the explicit clear operation — it returns the project to
+// unclassified (no experiential QA). Anything else is a usage error.
+function validateEnvironmentType(value) {
+  if (value === undefined || value === null) return null;
+  if (value === "artifact" || value === "terminal") return value;
+  throw usageError("environment_type must be 'artifact', 'terminal', or null.");
+}
+
 // ---------------------------------------------------------------------------
 // Crew home resolution (fail closed)
 // ---------------------------------------------------------------------------
@@ -102,11 +112,11 @@ function openDb(crewHome) {
         if (!/duplicate column name/i.test(e.message)) throw e;
       }
     }
+    const projectCols = db.prepare("PRAGMA table_info(projects)").all();
     // Migration: add visual_protocol column if missing (per-project visual
     // protocol toggle, 2026-09-12). Same idempotent PRAGMA-check pattern;
     // ADD COLUMN without a default leaves existing rows NULL, which is the
     // inherit state by design (no backfill step).
-    const projectCols = db.prepare("PRAGMA table_info(projects)").all();
     if (!projectCols.some((c) => c.name === "visual_protocol")) {
       try {
         db.exec("ALTER TABLE projects ADD COLUMN visual_protocol INTEGER CHECK (visual_protocol IN (0, 1))");
@@ -115,6 +125,19 @@ function openDb(crewHome) {
         if (!/duplicate column name/i.test(e.message)) throw e;
       }
     }
+    // Migration: add environment_type column if missing (per-project
+    // user-facing surface for experiential QA routing, 2026-09-17). Same
+    // idempotent PRAGMA-check pattern; ADD COLUMN without a default leaves
+    // existing rows NULL, which is the unclassified state by design
+    // (no backfill step).
+    if (!projectCols.some((c) => c.name === "environment_type")) {
+      try {
+        db.exec("ALTER TABLE projects ADD COLUMN environment_type TEXT CHECK (environment_type IN ('artifact', 'terminal'))");
+      } catch (e) {
+        // Another process may have added it concurrently; ignore duplicate-column errors.
+        if (!/duplicate column name/i.test(e.message)) throw e;
+      }
+    }
   }
   return db;
 }
@@ -152,6 +175,9 @@ function mapProject(row) {
     quiesced: !!row.quiesced,
     // Tri-state: null (inherit) stays null, never coerced to false.
     visual_protocol: row.visual_protocol == null ? null : !!row.visual_protocol,
+    // environment_type: 'artifact' | 'terminal' | null (unclassified).
+    // Null stays null — no coercion, no default.
+    environment_type: row.environment_type == null ? null : row.environment_type,
     created_at: row.created_at,
     updated_at: row.updated_at,
   };
@@ -1599,6 +1625,7 @@ commands["create-project"] = (db, args, ctx) => {
   }
   const timestamp = now();
   const visualProtocol = validateVisualProtocol(args.visual_protocol);
+  const environmentType = validateEnvironmentType(args.environment_type);
   const row = {
     id, display_name: displayName, repo_path: repoPath, deploy_type: deployType,
     deploy_slug: args.deploy_slug ?? null,
@@ -1606,6 +1633,7 @@ commands["create-project"] = (db, args, ctx) => {
     simultaneity: args.simultaneity ?? 2,
     quiesced: args.quiesced ? 1 : 0,
     visual_protocol: visualProtocol == null ? null : (visualProtocol ? 1 : 0),
+    environment_type: environmentType,
     created_at: timestamp, updated_at: timestamp,
   };
   if (!Number.isInteger(row.simultaneity) || row.simultaneity < 1 || row.simultaneity > 100) {
@@ -1613,9 +1641,9 @@ commands["create-project"] = (db, args, ctx) => {
   }
   db.prepare(
     `INSERT INTO projects (id, display_name, repo_path, deploy_type, deploy_slug,
-      description, simultaneity, quiesced, visual_protocol, created_at, updated_at)
+      description, simultaneity, quiesced, visual_protocol, environment_type, created_at, updated_at)
      VALUES (@id, @display_name, @repo_path, @deploy_type, @deploy_slug,
-      @description, @simultaneity, @quiesced, @visual_protocol, @created_at, @updated_at)`).run(row);
+      @description, @simultaneity, @quiesced, @visual_protocol, @environment_type, @created_at, @updated_at)`).run(row);
   const initialProvenance = tryStampInitialProvenance(db, ctx.crewHome, repoPath, deployType);
   return { project: mapProject(row), initial_provenance: initialProvenance };
 };
@@ -1654,13 +1682,16 @@ commands["update-project"] = (db, args) => {
     patch.simultaneity = args.simultaneity;
   }
   if (args.quiesced !== undefined) patch.quiesced = args.quiesced ? 1 : 0;
-  // NOT covered by the context-change guard below: visual_protocol is read
-  // once from launch args at dispatch time, so a mid-run change only affects
-  // future launches.
+  // NOT covered by the context-change guard below: visual_protocol and
+  // environment_type are read once from launch args at dispatch time, so a
+  // mid-run change only affects future launches.
   if (args.visual_protocol !== undefined) {
     const vp = validateVisualProtocol(args.visual_protocol);
     patch.visual_protocol = vp == null ? null : (vp ? 1 : 0);
   }
+  if (args.environment_type !== undefined) {
+    patch.environment_type = validateEnvironmentType(args.environment_type);
+  }
 
   const contextChanged =
     (args.repo_path !== undefined && args.repo_path !== current.repo_path) ||

package/lib/crew-release.sh

@@ -8,7 +8,7 @@
 #
 # Layout:
 #   ~/.jarvis/
-#     releases/<full-commit-hash>/   # immutable snapshot (workflows/ + lib/ + seed/workflows/ docs)
+#     releases/<full-commit-hash>/   # immutable snapshot (workflows/ + lib/ + seed/workflows/ + docs/)
 #     current -> releases/<hash>     # active release
 #     workflows -> current/workflows # convenience (cron/dispatcher reads this)
 #     lib -> current/lib             # convenience
@@ -231,12 +231,18 @@ cmd_deploy() {
       # Extract from committed tree (not working directory)
       _seed=""
       git cat-file -e "HEAD:seed/workflows" 2>/dev/null && _seed="seed/workflows" || true
+      # docs/ ships the shared crew references the workflow prompts read at
+      # runtime ($CREW_HOME/current/docs/terminal-ux.md) — the prompts are
+      # not the mechanism; the file they point at must exist in the release.
+      _docs=""
+      git cat-file -e "HEAD:docs" 2>/dev/null && _docs="docs" || true
       # shellcheck disable=SC2086
-      git archive HEAD -- workflows lib $_seed | tar -xC "$staging_dir"
+      git archive HEAD -- workflows lib $_seed $_docs | tar -xC "$staging_dir"
     else
       # Plain directory (npm install): copy directly
       [ -d workflows ] && cp -r workflows "$staging_dir/"
       [ -d lib ]       && cp -r lib "$staging_dir/"
+      [ -d docs ]      && cp -r docs "$staging_dir/"
       if [ -d seed/workflows ]; then
         mkdir -p "$staging_dir/seed"
         cp -r seed/workflows "$staging_dir/seed/"

package/lib/publish-npm.sh

@@ -212,7 +212,13 @@ if [ "$ALREADY_PUBLISHED" = "0" ]; then
 
     # 11. Publish. "previously published versions" means a retried Publish
     # already landed this version (the merge lock guarantees no other task
-    # picked it) — continue. Any other failure is fatal.
+    # picked it) — continue. A "staged version" 409 means npm accepted the
+    # publish but staged it: the PUT returned 2xx yet the version is
+    # invisible in the packument until it finalizes (~7 min observed
+    # 2026-09-17). Never re-PUT a staged version — the registry rejects it
+    # and the re-PUT proves nothing. Poll the registry at step 12 until it
+    # finalizes or the budget exhausts (fail closed). Any other failure is
+    # fatal.
     if PUB_OUT="$(python3 "$NPM_PUBLISH_PY" "$TGZ" 2>&1)"; then
       echo "PUBLISHED=$TARGET_VERSION"
     else
@@ -220,6 +226,10 @@ if [ "$ALREADY_PUBLISHED" = "0" ]; then
         *"previously published versions"*)
           echo "PUBLISHED_ALREADY=$TARGET_VERSION"
           ;;
+        *"staged version"*)
+          echo "PUBLISHED_STAGED=$TARGET_VERSION"
+          echo "publish staged by registry — polling for visibility, not re-PUTting"
+          ;;
         *)
           rm -f "$TGZ"
           fail "publish" "$(printf '%s\n' "$PUB_OUT" | tail -5)"
@@ -231,12 +241,20 @@ if [ "$ALREADY_PUBLISHED" = "0" ]; then
     # 12. Verify: ground truth is the registry, not any agent's summary.
     # The registry is eventually consistent: a publish followed by an
     # immediate read can observe the pre-publish version (canary 5a027278
-    # hit a stale read replica ~6s after publish). A single stale read must
-    # never park a landed publish, so this block retries with backoff and
-    # client cache-busting instead of failing on the first mismatch.
+    # hit a stale read replica ~6s after publish). Worse, npm may STAGE a
+    # publish: the PUT returns 2xx but the version stays invisible in the
+    # packument until it finalizes (~7 min observed 2026-09-17) — a
+    # re-PUT then 409s as "previously staged". A short budget would park
+    # a landed publish, so the default budget covers staged finalization
+    # with headroom (30 x 30s = 15 min, still bounded). A single stale
+    # read must never park a landed publish, so this block retries with
+    # backoff and client cache-busting instead of failing on the first
+    # mismatch. Budget exhaustion fails closed: a publish that never
+    # becomes visible is not claimed — a human with 2FA investigates
+    # (e.g. `npm stage approve`) and the version is never re-PUT blind.
     # STEP-12-ANCHOR: publish verification (retry-tolerant)
-    VERIFY_ATTEMPTS="${VERIFY_ATTEMPTS:-12}"
-    VERIFY_SLEEP_SECS="${VERIFY_SLEEP_SECS:-10}"
+    VERIFY_ATTEMPTS="${VERIFY_ATTEMPTS:-30}"
+    VERIFY_SLEEP_SECS="${VERIFY_SLEEP_SECS:-30}"
     REG=""
     for attempt in $(seq 1 "$VERIFY_ATTEMPTS"); do
       # --prefer-online busts npm's client-side packument cache; the retry

package/lib/read-ooda-verdict.js

@@ -13,8 +13,9 @@
 // Reads <phase-dir>/verdict.json and prints exactly one JSON line to stdout.
 //
 // Exit 0 with {ok:true, verdict, reason, summary, expected, actual, attempt,
-// visual_loop_unavailable} when the record exists, parses, has a verdict
-// field, the verdict equals --expect, and a FAIL carries a non-empty reason.
+// visual_loop_unavailable, terminal_loop_unavailable} when the record exists,
+// parses, has a verdict field, the verdict equals --expect, and a FAIL
+// carries a non-empty reason.
 //
 // visual_loop_unavailable (2026-09-16): a PASS verdict with missing
 // experiential evidence must never be terminal — the QA closeout parks
@@ -29,6 +30,16 @@
 //       (playwright, see-act, not possible, not installed, unavailable,
 //       could not run/drive/launch, no browser).
 //
+// terminal_loop_unavailable (2026-09-17): the terminal-surface counterpart.
+// A PASS with a terminal loop that never ran (the CLI would not execute)
+// must also park instead of stamping done. Same shape, terminal signals:
+//   (1) the OODA log has a terminal-action step with exit 3 and NOT
+//       POSSIBLE in the observation — the terminal QA contract for
+//       "the CLI will not run";
+//   (2) verdict.json's missing_evidence names CLI tool-unavailability
+//       (command not found, not recognized, no runtime, not installed,
+//       not possible, unavailable, could not run/execute/launch).
+//
 // Exit 2 with {ok:false, code, error} when:
 //   missing      — verdict.json is absent (the agent never wrote one)
 //   corrupt      — unparseable JSON, or parsed but no verdict field
@@ -103,6 +114,7 @@ function main() {
     actual: record.actual === undefined ? "" : record.actual,
     attempt: record.attempt === undefined ? "" : record.attempt,
     visual_loop_unavailable: visualLoopUnavailable(dir, record),
+    terminal_loop_unavailable: terminalLoopUnavailable(dir, record),
   }) + "\n");
 }
 
@@ -152,4 +164,50 @@ function visualLoopUnavailable(dir, record) {
   return oodaLogUnavailable(dir) || missingEvidenceUnavailable(record);
 }
 
+// Terminal-loop availability: true when the experiential terminal loop
+// could not run. Signal 1 — a terminal-action OODA step exited 3 with NOT
+// POSSIBLE in its observation (the terminal QA contract for "the CLI will
+// not run"). Signal 2 — the verdict's own missing_evidence names CLI
+// tool-unavailability. Same string-match shape as the visual version, never
+// a judgment about report prose.
+const TERMINAL_ACTIONS = { terminal: true };
+const TERMINAL_TOOL_UNAVAILABLE = /(command not found|not recognized|no runtime|not possible|not installed|unavailable|could not (run|execute|launch)|no cli)/i;
+
+function oodaLogTerminalUnavailable(dir) {
+  let text;
+  try {
+    text = readFileSync(join(dir, "ooda-log.jsonl"), "utf8");
+  } catch (e) {
+    return false;
+  }
+  const lines = text.split("\n");
+  for (let k = 0; k < lines.length; k++) {
+    const line = lines[k].trim();
+    if (!line) continue;
+    let step;
+    try {
+      step = JSON.parse(line);
+    } catch (e) {
+      continue;
+    }
+    if (!step || !TERMINAL_ACTIONS[step.action]) continue;
+    if (step.exit === 3 && /not possible/i.test(String(step.observation || ""))) return true;
+  }
+  return false;
+}
+
+function missingEvidenceTerminalUnavailable(record) {
+  let me = record.missing_evidence;
+  if (me === undefined) me = record.missing;
+  if (!Array.isArray(me)) return false;
+  for (let k = 0; k < me.length; k++) {
+    if (TERMINAL_TOOL_UNAVAILABLE.test(String(me[k]))) return true;
+  }
+  return false;
+}
+
+function terminalLoopUnavailable(dir, record) {
+  return oodaLogTerminalUnavailable(dir) || missingEvidenceTerminalUnavailable(record);
+}
+
 main();

package/lib/schema.sql

@@ -25,6 +25,15 @@ CREATE TABLE IF NOT EXISTS projects (
   simultaneity  INTEGER NOT NULL DEFAULT 2 CHECK (simultaneity >= 0 AND simultaneity <= 100),
   quiesced      INTEGER NOT NULL DEFAULT 0 CHECK (quiesced IN (0, 1)),
   visual_protocol INTEGER CHECK (visual_protocol IN (0, 1)),
+  -- environment_type: the project's user-facing surface for experiential QA.
+  -- 'artifact' = a rendered web UI served from a built artifact (Hazel drives
+  -- it with the see-act browser loop). 'terminal' = a command-line interface
+  -- (Hazel drives it herself and keeps attempt-scoped transcripts). NULL =
+  -- unclassified: no experiential QA — the same as today's non-artifact
+  -- behavior. Nullable by design: existing rows stay NULL (no backfill), and
+  -- deploy_type is NOT reused for this (it names the deployment target, not
+  -- the UX surface a user experiences).
+  environment_type TEXT CHECK (environment_type IN ('artifact', 'terminal')),
   created_at    TEXT NOT NULL,
   updated_at    TEXT NOT NULL
 );

package/lib/update-watch.js

@@ -453,6 +453,20 @@ async function dashboardCheck(deps, ctx, summary) {
     "\n" +
     "Automatic dashboard upgrade: " + oldSha7 + " -> " + sha.slice(0, 7) + ".\n" +
     "Filed by the update watcher (policy auto_update_dashboard).\n" +
+    // Enrollment guidance: when the watcher never recorded a trusted base,
+    // the old sha is "unknown" and the ancestor check below parks
+    // fail-closed by design. A human establishes the base once with the
+    // enroll command, then re-queues this task.
+    (!recorded
+      ? "\nENROLLMENT: this crew has no trusted dashboard base — the watcher\n" +
+        "was never told which dashboard commit the live artifact was deployed\n" +
+        "from (fresh watcher state, or state reset). The ancestor check below\n" +
+        "cannot run against \"unknown\", so park this task and say so.\n" +
+        "A human establishes the base once, then re-queues:\n" +
+        "  node " + crewHome + "/current/lib/update-watch.js --crew-home " + crewHome + " --record-dashboard-sha <sha>\n" +
+        "The sha must be the commit the live artifact was actually published\n" +
+        "from — verify it exists in " + proj.repo_path + ", never guess.\n"
+      : "") +
     "\n" +
     "Journey (execute mechanically, no judgment):\n" +
     "1. In " + proj.repo_path + ": git fetch origin && git rev-parse origin/HEAD — must\n" +
@@ -487,6 +501,47 @@ async function dashboardCheck(deps, ctx, summary) {
   }
 }
 
+// ── Dashboard enrollment ─────────────────────────────────────────────
+// Records the trusted dashboard base sha in the watcher state. This is the
+// enrollment operation: a human (or crew-init on first install) declares
+// "this crew's dashboard artifact was deployed from this commit". The
+// watcher files dashboard upgrades as <recorded> -> <remote>; without a
+// recorded base the old sha is "unknown" and the filed task parks
+// fail-closed by design. Moving an existing base is a human decision —
+// pass { force: true }.
+// Returns { ok, projectId, sha, action: "enrolled" | "moved" | "already" }.
+async function enrollDashboardBase(deps, sha, opts) {
+  opts = opts || {};
+  const crewHome = deps.crewHome;
+  if (!/^[0-9a-f]{40}$/i.test(sha || "")) {
+    throw new Error("--record-dashboard-sha needs a 40-hex commit sha");
+  }
+  const projects = await deps.listProjects();
+  const proj = (projects || []).find(function (p) {
+    return p && p.deploy_type === "artifact" && p.repo_path;
+  });
+  if (!proj) throw new Error("no artifact project registered — cannot enroll a dashboard base");
+  const projectId = proj.id || proj.project_id;
+  try {
+    await deps.gitCatFile(proj.repo_path, sha);
+  } catch (e) {
+    throw new Error("sha " + sha.slice(0, 7) + " not found in " + proj.repo_path + " — verify the commit the live artifact was deployed from, never guess");
+  }
+  const state = readState(crewHome);
+  state.dashboard = state.dashboard || {};
+  const existing = state.dashboard[projectId] && state.dashboard[projectId].last_filed_sha;
+  if (existing && existing.toLowerCase() === sha.toLowerCase()) {
+    return { ok: true, projectId: projectId, sha: existing, action: "already" };
+  }
+  if (existing && !opts.force) {
+    throw new Error("dashboard base already enrolled as " + existing.slice(0, 7) + " — pass --force to move it (a human decision)");
+  }
+  state.dashboard[projectId] = { last_filed_sha: sha.toLowerCase() };
+  writeState(crewHome, state);
+  appendLog(crewHome, "enroll", "dashboard base " + (existing ? "moved" : "enrolled") + ": " + projectId + " @ " + sha.slice(0, 7));
+  return { ok: true, projectId: projectId, sha: sha.toLowerCase(), action: existing ? "moved" : "enrolled" };
+}
+
 // ── Pipeline ─────────────────────────────────────────────────────────
 
 async function run(deps) {
@@ -585,6 +640,11 @@ function buildRealDeps(crewHome) {
       // constant ".crew-version".
       return shOut("git", ["-C", repoPath, "show", sha + ":" + filePath]).trim();
     },
+    gitCatFile: function (repoPath, sha) {
+      // Throws when the object is missing or not a commit; the enrollment
+      // command fails closed on it.
+      return shOut("git", ["-C", repoPath, "cat-file", "-e", sha + "^{commit}"]).trim();
+    },
     createTask: function (args) { return apiCall(crewHome, "create-task", args).task; }
   };
 }
@@ -594,13 +654,30 @@ function buildRealDeps(crewHome) {
 function main() {
   const args = process.argv.slice(2);
   let crewHome = null;
+  let enrollSha = null;
+  let enrollForce = false;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--crew-home" && i + 1 < args.length) crewHome = args[i + 1];
+    if (args[i] === "--record-dashboard-sha" && i + 1 < args.length) enrollSha = args[i + 1];
+    if (args[i] === "--force") enrollForce = true;
   }
   if (!crewHome) {
-    process.stderr.write("usage: node update-watch.js --crew-home <path>\n");
+    process.stderr.write("usage: node update-watch.js --crew-home <path> [--record-dashboard-sha <sha> [--force]]\n");
     process.exit(2);
   }
+  if (enrollSha) {
+    enrollDashboardBase(buildRealDeps(crewHome), enrollSha, { force: enrollForce }).then(
+      function (res) {
+        process.stdout.write("update-watch: dashboard base " + res.action + ": " + res.projectId + " @ " + res.sha.slice(0, 7) + "\n");
+        process.exit(0);
+      },
+      function (e) {
+        process.stderr.write("update-watch: enrollment failed (" + firstLine(e) + ")\n");
+        process.exit(1);
+      }
+    );
+    return;
+  }
   run(buildRealDeps(crewHome)).then(
     function (res) {
       res.summary.forEach(function (line) { process.stdout.write(line + "\n"); });
@@ -624,6 +701,7 @@ module.exports = {
   dashboardDecision: dashboardDecision,
   crewVersionOrdering: crewVersionOrdering,
   fileCrewUpgrade: fileCrewUpgrade,
+  enrollDashboardBase: enrollDashboardBase,
   readState: readState,
   writeState: writeState,
   appendLog: appendLog,

package/lib/ux-doctrine.js

@@ -0,0 +1,63 @@
+// ux-doctrine.js — UX-surface doctrine page resolution.
+//
+// One canonical doctrine page per environment_type value: the crew reads
+// the same page per surface, resolved mechanically from project config —
+// never from prose, never hardcoded per-prompt. Adding a surface is one
+// line in DOCTRINE_PAGES plus one docs page; the workflows resolve the
+// page from environment_type and hand the path to every phase prompt.
+//
+// Workflows mirror this map inline (one line) because the workflow
+// runtime's relative-import support is unverified — tests pin the mirror
+// against this file, so the two can never silently diverge.
+//
+// Pure and deterministic: no clock, no randomness, no I/O.
+"use strict";
+
+const { existsSync } = require("node:fs");
+const { join } = require("node:path");
+
+// THE MAP. environment_type value -> doctrine page filename, relative to
+// the release docs dir ($CREW_HOME/current/docs/). null is unclassified —
+// it maps to no page, never to a guess.
+const DOCTRINE_PAGES = {
+  artifact: "artifact-ux.md",
+  terminal: "terminal-ux.md",
+};
+
+function doctrinePage(environmentType) {
+  if (environmentType == null) return null;
+  return Object.prototype.hasOwnProperty.call(DOCTRINE_PAGES, environmentType)
+    ? DOCTRINE_PAGES[environmentType]
+    : null;
+}
+
+// Absolute path of the doctrine page for a crew home, or null when the
+// surface is unclassified/unknown. Does not check the file exists —
+// callers that need existence use doctrinePageExists.
+function doctrinePath(crewHome, environmentType) {
+  const page = doctrinePage(environmentType);
+  return page ? join(crewHome, "current", "docs", page) : null;
+}
+
+function doctrinePageExists(crewHome, environmentType) {
+  const p = doctrinePath(crewHome, environmentType);
+  return p ? existsSync(p) : false;
+}
+
+module.exports = { DOCTRINE_PAGES, doctrinePage, doctrinePath, doctrinePageExists };
+
+if (require.main === module) {
+  // CLI: node ux-doctrine.js --page <environment_type>
+  //      node ux-doctrine.js --path <crewHome> <environment_type>
+  const args = process.argv.slice(2);
+  if (args[0] === "--page" && args.length === 2) {
+    const page = doctrinePage(args[1] === "null" ? null : args[1]);
+    console.log(page === null ? "null" : page);
+  } else if (args[0] === "--path" && args.length === 3) {
+    const p = doctrinePath(args[1], args[2] === "null" ? null : args[2]);
+    console.log(p === null ? "null" : p);
+  } else {
+    console.error("usage: node ux-doctrine.js --page <environment_type|null> | --path <crewHome> <environment_type|null>");
+    process.exit(2);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muse-crew",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Opinionated orchestration for Muse — workflows, identities, and tooling for autonomous software development.",
   "license": "UNLICENSED",
   "private": false,