factory-ai 1.0.0

package/src/tui.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import blessed from "neo-blessed";
+import { createOperator } from "./operator.js";
+
+if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("Factory AI UI requires an interactive terminal");
+
+const operator = createOperator();
+const screen = blessed.screen({ smartCSR: true, title: "Factory AI", fullUnicode: true, dockBorders: true });
+const colors = { bg: "#0d0f12", panel: "#15191f", border: "#303743", text: "#d9e0e8", muted: "#7f8b99", accent: "#78dba9", warn: "#efc46b", danger: "#ef7d7d", blue: "#77a8ff" };
+
+blessed.box({ parent: screen, top: 0, left: 0, width: "100%", height: 3, tags: true, style: { bg: colors.panel, fg: colors.text }, content: "  {bold}{#78dba9-fg}FACTORY AI{/}  {/bold}  private coding organization" });
+const menu = blessed.list({ parent: screen, top: 3, left: 0, width: 23, bottom: 2, border: { type: "line" }, label: " Navigate ", keys: true, mouse: true, vi: true, items: ["Overview", "Objectives", "Agents", "Secrets", "Capabilities", "Logs", "Settings"], style: { bg: colors.panel, fg: colors.text, border: { fg: colors.border }, selected: { bg: colors.accent, fg: "#07130d", bold: true }, item: { fg: colors.text } } });
+const main = blessed.box({ parent: screen, top: 3, left: 23, right: 0, bottom: 2, border: { type: "line" }, label: " Overview ", tags: true, scrollable: true, alwaysScroll: true, keys: true, mouse: true, vi: true, scrollbar: { ch: "▐", style: { fg: colors.accent } }, padding: { left: 2, right: 2 }, style: { bg: colors.bg, fg: colors.text, border: { fg: colors.border } } });
+const footer = blessed.box({ parent: screen, bottom: 0, left: 0, width: "100%", height: 2, tags: true, style: { bg: colors.panel, fg: colors.muted }, content: "  {bold}n{/} new objective   {bold}r{/} refresh   {bold}a{/} add secret   {bold}p/u{/} pause/resume   {bold}q{/} quit" });
+
+let dashboard;
+let capabilities;
+let secrets;
+let logs;
+let section = "Overview";
+
+function status(message, color = colors.muted) {
+  footer.setContent(`  {${color}-fg}${message}{/}   {bold}n{/} new   {bold}r{/} refresh   {bold}q{/} quit`);
+  screen.render();
+}
+
+function badge(value) {
+  const color = value === "succeeded" || value === "complete" ? colors.accent : value === "failed" || value === "blocked" ? colors.danger : value === "running" ? colors.blue : colors.warn;
+  return `{${color}-fg}${value}{/}`;
+}
+
+function renderOverview() {
+  const cost = dashboard?.cost ? `${dashboard.cost.currency} ${dashboard.cost.monthToDate.toFixed(2)}` : "unavailable";
+  const counts = Object.entries(dashboard?.summary?.objectives ?? {}).map(([key, value]) => `${key} ${value}`).join("  ") || "none";
+  const recent = (dashboard?.objectives ?? []).slice(-8).reverse().map((objective) => `  ${badge(objective.status.padEnd(9))}  {bold}${objective.objective}{/}\n             ${objective.repository ?? ""}`).join("\n\n");
+  main.setContent(`{bold}System{/}\n\n  Queue      {#78dba9-fg}${dashboard?.queue?.active ?? 0}{/}\n  Dead letter ${dashboard?.queue?.deadLetter ?? 0}\n  Azure MTD  {#efc46b-fg}${cost}{/}\n  Objectives ${counts}\n\n{bold}Recent objectives{/}\n\n${recent || "  No objectives yet."}`);
+}
+
+function renderObjectives() {
+  main.setContent((dashboard?.objectives ?? []).slice().reverse().map((objective) => {
+    const tasks = objective.tasks.map((task) => `    ${badge(task.state.padEnd(9))} ${task.role.padEnd(9)} {#7f8b99-fg}${task.model}{/}\n               ${task.title}`).join("\n");
+    return `${badge(objective.status)} {bold}${objective.objective}{/}\n  ${objective.id}\n${tasks}${objective.pullRequest ? `\n  PR ${objective.pullRequest}` : ""}${objective.blocker ? `\n  {#ef7d7d-fg}${objective.blocker}{/}` : ""}`;
+  }).join("\n\n────────────────────────────────────────────────────────\n\n") || "No objectives." );
+}
+
+function renderAgents() {
+  const agents = (dashboard?.objectives ?? []).flatMap((objective) => objective.tasks.map((task) => ({ objective: objective.objective, ...task }))).filter((task) => !["succeeded"].includes(task.state));
+  main.setContent(agents.map((task) => `${badge(task.state.padEnd(9))} {bold}${task.role}{/}  ${task.model}\n  ${task.title}\n  {#7f8b99-fg}${task.objective}{/}`).join("\n\n") || "No active agents.");
+}
+
+function renderSecrets() {
+  main.setContent(`{bold}Global Azure Key Vault{/}\n{#7f8b99-fg}Values are never displayed. Press a to add or rotate a secret.{/}\n\n${(secrets ?? []).map((item) => `  {#78dba9-fg}●{/} ${item.name.padEnd(55)} ${item.updated ?? ""}`).join("\n") || "  Loading or empty."}`);
+}
+
+function renderCapabilities() {
+  const skills = Object.entries(capabilities?.skills ?? {}).map(([name, item]) => `  {#77a8ff-fg}skill{/}  ${name.padEnd(36)} ${item.roles.join(", ")}`).join("\n");
+  const mcp = Object.entries(capabilities?.mcp ?? {}).map(([name, item]) => `  {#78dba9-fg}mcp{/}    ${name.padEnd(36)} ${item.roles.join(", ")}`).join("\n");
+  main.setContent(`{bold}Skills{/}\n\n${skills}\n\n{bold}MCP servers{/}\n\n${mcp}`);
+}
+
+function renderSettings() {
+  const config = operator.config();
+  main.setContent(`{bold}Runtime{/}\n\n  Resource group  ${config.resourceGroup}\n  VM              ${config.vm}\n  Service Bus     ${config.namespace}\n  Key Vault       ${config.vault}\n\n{bold}Model policy{/}\n\n  Scout           GPT-5.4 nano\n  Simple builder  Kimi K2.7-Code\n  Builder         GPT-5.6\n  Tester          GPT-5.4\n  Critical roles  GPT-5.6\n\n{#7f8b99-fg}Run factory setup to change providers or role routes.{/}`);
+}
+
+function render() {
+  main.setLabel(` ${section} `);
+  if (section === "Overview") renderOverview();
+  else if (section === "Objectives") renderObjectives();
+  else if (section === "Agents") renderAgents();
+  else if (section === "Secrets") renderSecrets();
+  else if (section === "Capabilities") renderCapabilities();
+  else if (section === "Logs") main.setContent(logs ?? "Loading logs...");
+  else renderSettings();
+  main.setScrollPerc(0);
+  screen.render();
+}
+
+async function refresh() {
+  status("Refreshing...");
+  try {
+    dashboard = await operator.dashboard();
+    if (section === "Capabilities" && !capabilities) capabilities = await operator.capabilities();
+    if (section === "Secrets") secrets = await operator.listSecrets();
+    if (section === "Logs") logs = await operator.logs();
+    render();
+    status(`Updated ${new Date().toLocaleTimeString()}`);
+  } catch (error) { status(error.message, colors.danger); }
+}
+
+function ask(label, { secret = false } = {}) {
+  return new Promise((resolve) => {
+    const prompt = blessed.textbox({ parent: screen, top: "center", left: "center", width: "70%", height: 5, border: { type: "line" }, label: ` ${label} `, inputOnFocus: true, keys: true, mouse: true, censor: secret, style: { bg: colors.panel, fg: colors.text, border: { fg: colors.accent } } });
+    prompt.focus();
+    prompt.readInput((_, value) => { prompt.destroy(); screen.render(); resolve(value?.trim() ?? ""); });
+    screen.render();
+  });
+}
+
+async function submitObjective() {
+  const repository = await ask("Repository owner/name");
+  if (!repository) return;
+  const objective = await ask("CEO objective");
+  if (!objective) return;
+  status("Submitting objective...");
+  try { const result = await operator.submit(repository, objective); status(`Queued ${result.objectiveId ?? "objective"}`, colors.accent); await refresh(); } catch (error) { status(error.message, colors.danger); }
+}
+
+async function addSecret() {
+  if (section !== "Secrets") return status("Open Secrets before adding a key", colors.warn);
+  const name = await ask("Secret name");
+  if (!name) return;
+  const value = await ask("Secret value", { secret: true });
+  if (!value) return;
+  status("Storing secret...");
+  try { await operator.setSecret(name, value); secrets = await operator.listSecrets(); renderSecrets(); status(`Stored ${name}`, colors.accent); } catch (error) { status(error.message, colors.danger); }
+}
+
+menu.on("select", async (_, index) => { section = menu.getItem(index).getText(); render(); await refresh(); menu.focus(); });
+screen.key(["q", "C-c"], () => process.exit(0));
+screen.key("r", refresh);
+screen.key("n", submitObjective);
+screen.key("a", addSecret);
+screen.key("p", async () => { status("Pausing workers..."); try { await operator.control("pause"); status("Workers paused", colors.warn); } catch (error) { status(error.message, colors.danger); } });
+screen.key("u", async () => { status("Resuming workers..."); try { await operator.control("resume"); status("Workers active", colors.accent); } catch (error) { status(error.message, colors.danger); } });
+screen.key("tab", () => menu.focus());
+menu.focus();
+screen.render();
+await refresh();
+setInterval(refresh, 30_000).unref();

package/src/validation.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { ROLES } from "./routing.js";
+
+const identifier = z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/);
+const repository = z.string().url().max(2048).refine((value) => {
+  const parsed = new URL(value);
+  return parsed.protocol === "https:" && parsed.hostname === "github.com" && /^\/[^/]+\/[^/]+(?:\.git)?$/.test(parsed.pathname);
+}, "Repository must be an HTTPS github.com repository URL");
+
+const objectiveSchema = z.object({
+  id: identifier,
+  type: z.literal("objective"),
+  objective: z.string().trim().min(3).max(12_000),
+  repository,
+  baseBranch: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]{0,127}$/).default("main"),
+  createdAt: z.string().datetime().optional(),
+}).strict();
+
+export const taskSchema = z.object({
+  id: identifier,
+  role: z.enum(ROLES),
+  title: z.string().trim().min(1).max(200),
+  instructions: z.string().trim().min(3).max(20_000),
+  dependsOn: z.array(identifier).max(16).default([]),
+  capabilities: z.array(identifier).max(12).default([]),
+  complexity: z.enum(["simple", "complex"]).default("complex"),
+}).strict();
+
+const planSchema = z.object({
+  executiveIntent: z.string().trim().min(1).max(4000).optional(),
+  tasks: z.array(taskSchema).min(1).max(32),
+}).strict();
+
+const taskResultSchema = z.object({
+  summary: z.string().trim().min(1).max(4000),
+  checks: z.array(z.string().trim().min(1).max(1000)).max(50),
+  risks: z.array(z.string().trim().min(1).max(1000)).max(50),
+  approval: z.enum(["approved", "changes_requested", "not_applicable"]),
+}).strict();
+
+export const workMessageSchema = z.object({
+  type: z.literal("task"),
+  objectiveId: identifier,
+  task: taskSchema,
+}).strict();
+
+const resultMessageSchema = taskResultSchema.extend({
+  type: z.literal("result"),
+  objectiveId: identifier,
+  taskId: identifier,
+  status: z.literal("succeeded"),
+  commit: z.string().regex(/^[0-9a-f]{40,64}$/),
+  branch: z.string().min(1).max(255).regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/),
+}).strict();
+
+export function parseObjective(value) {
+  return objectiveSchema.parse(value);
+}
+
+export function parsePlan(value) {
+  return planSchema.parse(value);
+}
+
+export function parseWorkMessage(value) {
+  return workMessageSchema.parse(value);
+}
+
+export function parseTaskResult(value) {
+  return taskResultSchema.parse(value);
+}
+
+export function parseResultMessage(value) {
+  return resultMessageSchema.parse(value);
+}

package/src/worker.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { loadConfig } from "./config.js";
+import { createBus } from "./bus.js";
+import { WorkspaceManager } from "./workspace.js";
+import { log } from "./log.js";
+import { loadRuntimeSecrets } from "./secrets.js";
+import { run } from "./process.js";
+import { AgentExecutor } from "./agent-executor.js";
+import { sendMessage } from "./bus.js";
+import { ContainerAgentRunner } from "./container-runner.js";
+import { ScannerSuite } from "./scanner-suite.js";
+
+const config = loadConfig();
+Object.assign(process.env, await loadRuntimeSecrets(config));
+await run("gh", ["auth", "setup-git"], { timeoutMs: 60_000 });
+const bus = createBus(config, config.agentQueue, config.controlQueue);
+const sendControl = (message) => sendMessage(bus.sender, message, `${message.objectiveId}:${message.type}:${message.taskId ?? "plan"}:v1`, message.objectiveId);
+const executor = new AgentExecutor({
+  workspaces: new WorkspaceManager(config.workspaceDir, config.timeoutMs),
+  agentRunner: new ContainerAgentRunner({ image: config.workerImage, memoryDir: config.memoryDir, timeoutMs: config.timeoutMs }),
+  scannerSuite: new ScannerSuite(),
+  sendControl,
+});
+
+let shuttingDown = false;
+const subscription = bus.receiver.subscribe({
+  processMessage: async (message) => {
+    const body = message.body;
+    try {
+      await executor.process(body);
+      await bus.receiver.completeMessage(message);
+    } catch (error) {
+      log("error", "message_failed", {
+        messageId: String(message.messageId),
+        type: body?.type,
+        deliveryCount: message.deliveryCount,
+        error: error.message,
+      });
+      const permanent = error.message.includes("content_filter") || message.deliveryCount >= config.maxDeliveryCount;
+      if (permanent) {
+        await sendControl({
+          type: "failure_result",
+          objectiveId: body?.objectiveId,
+          taskId: body?.task?.id,
+          error: String(error.message).slice(0, 2000),
+        });
+        await bus.receiver.deadLetterMessage(message, {
+          deadLetterReason: "MaxDeliveryExceeded",
+          deadLetterErrorDescription: String(error.message).slice(0, 4096),
+        });
+      } else {
+        await bus.receiver.abandonMessage(message);
+      }
+    }
+  },
+  processError: async ({ error, errorSource }) => {
+    log("error", "service_bus_error", { source: errorSource, error: error.message });
+  },
+}, {
+  autoCompleteMessages: false,
+  maxConcurrentCalls: config.concurrency,
+  maxAutoLockRenewalDurationInMs: (config.timeoutMs * 4) + 300_000,
+});
+
+async function shutdown(signal) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log("info", "worker_shutdown", { signal });
+  await subscription.close();
+  await bus.receiver.close();
+  await bus.sender.close();
+  await bus.client.close();
+}
+
+process.once("SIGTERM", () => shutdown("SIGTERM").catch((error) => log("error", "shutdown_failed", { error: error.message })));
+process.once("SIGINT", () => shutdown("SIGINT").catch((error) => log("error", "shutdown_failed", { error: error.message })));
+log("info", "worker_started", { concurrency: config.concurrency, queue: config.agentQueue });

package/src/workspace-tools.js

@@ -0,0 +1,121 @@
+import { lstat, mkdir, readFile, readdir, realpath, rename, writeFile } from "node:fs/promises";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { run } from "./process.js";
+
+const ALLOWED_COMMANDS = new Set(["git", "ls", "node", "npm", "npx", "pwd", "rg"]);
+const DENIED_GIT_OPERATIONS = new Set(["credential", "push", "remote"]);
+
+function lexicalPath(root, requested) {
+  const target = path.resolve(root, requested);
+  if (target !== root && !target.startsWith(`${root}${path.sep}`)) throw new Error("Path is outside workspace");
+  return target;
+}
+
+async function existingPath(root, requested) {
+  const target = lexicalPath(root, requested);
+  const resolved = await realpath(target);
+  if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`)) throw new Error("Path is outside workspace");
+  return resolved;
+}
+
+async function writeTarget(root, requested) {
+  const target = lexicalPath(root, requested);
+  await mkdir(path.dirname(target), { recursive: true });
+  const parent = await realpath(path.dirname(target));
+  if (parent !== root && !parent.startsWith(`${root}${path.sep}`)) throw new Error("Path is outside workspace");
+  try {
+    const metadata = await lstat(target);
+    if (metadata.isSymbolicLink()) throw new Error("Symbolic link writes are not allowed");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return target;
+}
+
+async function walk(directory, root, output, limit) {
+  for (const entry of (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (entry.name === ".git" || output.length >= limit) continue;
+    const absolute = path.join(directory, entry.name);
+    const relative = path.relative(root, absolute);
+    if (entry.isDirectory()) await walk(absolute, root, output, limit);
+    else if (entry.isFile()) output.push(relative);
+  }
+}
+
+export function createWorkspaceTools(rootInput, { execute = run } = {}) {
+  const root = realpathSync(path.resolve(rootInput));
+  return {
+    read_file: {
+      description: "Read a UTF-8 file inside the assigned workspace.",
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string" } },
+        required: ["path"],
+        additionalProperties: false,
+      },
+      execute: async ({ path: requested }) => {
+        const value = await readFile(await existingPath(root, requested), "utf8");
+        if (Buffer.byteLength(value) > 512_000) throw new Error("File exceeds 512000 bytes");
+        return value;
+      },
+    },
+    write_file: {
+      description: "Atomically replace a UTF-8 file inside the assigned workspace.",
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string" }, content: { type: "string" } },
+        required: ["path", "content"],
+        additionalProperties: false,
+      },
+      execute: async ({ path: requested, content }) => {
+        if (Buffer.byteLength(content) > 1_000_000) throw new Error("Content exceeds 1000000 bytes");
+        const target = await writeTarget(root, requested);
+        const temporary = `${target}.${process.pid}.tmp`;
+        await writeFile(temporary, content, { mode: 0o640 });
+        await rename(temporary, target);
+        return "written";
+      },
+    },
+    list_files: {
+      description: "List files recursively inside the assigned workspace.",
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string" } },
+        required: ["path"],
+        additionalProperties: false,
+      },
+      execute: async ({ path: requested }) => {
+        const directory = await existingPath(root, requested);
+        const output = [];
+        await walk(directory, root, output, 2000);
+        return JSON.stringify(output);
+      },
+    },
+    run_command: {
+      description: "Run an allowlisted noninteractive development command in the assigned workspace.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: { type: "string", enum: [...ALLOWED_COMMANDS] },
+          args: { type: "array", items: { type: "string" }, maxItems: 100 },
+        },
+        required: ["command", "args"],
+        additionalProperties: false,
+      },
+      execute: async ({ command, args }) => {
+        if (!ALLOWED_COMMANDS.has(command)) throw new Error(`Command not allowed: ${command}`);
+        if (command === "git" && DENIED_GIT_OPERATIONS.has(args[0])) throw new Error(`Git operation not allowed: ${args[0]}`);
+        if (command === "npx" && args[0] !== "--no-install") throw new Error("npx requires --no-install");
+        const result = await execute(command, args, {
+          cwd: root,
+          timeoutMs: 900_000,
+          maxOutputBytes: 2_000_000,
+          inheritEnv: false,
+          env: { PATH: process.env.PATH, HOME: "/tmp/agent-home", CI: "true", NO_COLOR: "1" },
+        });
+        return `${result.stdout}${result.stderr ? `\nSTDERR:\n${result.stderr}` : ""}`.slice(-2_000_000);
+      },
+    },
+  };
+}

package/src/workspace.js

@@ -0,0 +1,78 @@
+import { mkdir, rename, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { run } from "./process.js";
+
+async function exists(target) {
+  try {
+    await stat(target);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+export class WorkspaceManager {
+  constructor(root, timeoutMs) {
+    this.root = root;
+    this.timeoutMs = timeoutMs;
+  }
+
+  rootFor(objectiveId) {
+    return path.join(this.root, objectiveId);
+  }
+
+  taskDirectory(objectiveId, taskId) {
+    return path.join(this.rootFor(objectiveId), "tasks", taskId);
+  }
+
+  async ensureObjective(objective) {
+    const root = this.rootFor(objective.id);
+    const control = path.join(root, "control");
+    if (!(await exists(path.join(control, ".git")))) {
+      await mkdir(root, { recursive: true, mode: 0o750 });
+      const temporary = `${control}.clone-${process.pid}`;
+      await rm(temporary, { recursive: true, force: true });
+      await run("git", ["clone", "--branch", objective.baseBranch, "--single-branch", objective.repository, temporary], {
+        timeoutMs: this.timeoutMs,
+      });
+      await rename(temporary, control);
+      await run("git", ["-C", control, "config", "user.name", "Factory AI"]);
+      await run("git", ["-C", control, "config", "user.email", "factory-ai@localhost"]);
+    }
+    return control;
+  }
+
+  async prepareTask(objective, task, dependencyCommits = []) {
+    const directory = this.taskDirectory(objective.id, task.id);
+    if (await exists(directory)) return directory;
+    await mkdir(path.dirname(directory), { recursive: true, mode: 0o750 });
+    const base = dependencyCommits[0] ?? `origin/${objective.baseBranch}`;
+    const branch = `factory-ai/${objective.id}/${task.id}`;
+    await run("git", ["clone", objective.repository, directory], { timeoutMs: this.timeoutMs });
+    await run("git", ["-C", directory, "config", "user.name", "Factory AI"]);
+    await run("git", ["-C", directory, "config", "user.email", "factory-ai@localhost"]);
+    await run("git", ["-C", directory, "checkout", "-b", branch, base], { timeoutMs: this.timeoutMs });
+    for (const commit of dependencyCommits.slice(1)) {
+      await run("git", ["-C", directory, "merge", "--no-edit", commit], { timeoutMs: this.timeoutMs });
+    }
+    await run("git", ["-C", directory, "push", "--set-upstream", "origin", branch], { timeoutMs: this.timeoutMs });
+    return directory;
+  }
+
+  async checkpoint(directory, objective, task) {
+    await run("git", ["-C", directory, "add", "-A"]);
+    const diff = await run("git", ["-C", directory, "diff", "--cached", "--quiet"], { allowExitCodes: [0, 1] });
+    if (diff.code === 1) {
+      await run("git", ["-C", directory, "commit", "-m", `factory-ai(${task.role}): ${task.title}`], {
+        timeoutMs: this.timeoutMs,
+      });
+    }
+    const { stdout } = await run("git", ["-C", directory, "rev-parse", "HEAD"]);
+    const commit = stdout.trim();
+    const branch = `factory-ai/${objective.id}/${task.id}`;
+    await run("git", ["-C", directory, "push", "--set-upstream", "origin", branch], { timeoutMs: this.timeoutMs });
+    return { commit, branch };
+  }
+
+}

package/templates/project/architecture.md

@@ -0,0 +1,3 @@
+# Architecture
+
+Record entry points, boundaries, data stores, external services, and critical flows.

package/templates/project/commands.md

@@ -0,0 +1,3 @@
+# Commands
+
+Record install, development, typecheck, lint, test, build, and deployment commands.

package/templates/project/decisions.md

@@ -0,0 +1,3 @@
+# Decisions
+
+Record durable decisions and their tradeoffs. Do not store transient discussion.

package/templates/project/handoff.md

@@ -0,0 +1,3 @@
+# Handoff
+
+Record current state, active objective, completed verification, blockers, and next actions.

package/templates/project/project.md

@@ -0,0 +1,3 @@
+# Project
+
+Describe the product, users, outcomes, repository shape, and current stage.

package/templates/project/risks.md

@@ -0,0 +1,3 @@
+# Risks
+
+Record security, data-loss, reliability, cost, and regression risks.