@joenandez/academy 0.4.0 → 0.5.12

package/scripts/cli/skills.mjs

@@ -0,0 +1,170 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { ACADEMY_HOME, ACADEMY_ROOT, KIND_PROFILES } from './core.mjs';
+import { NIGHTLY_REPORT_EVIDENCE } from './nightly.mjs';
+import { ownerSkillValues } from './owner-config.mjs';
+import { proposalsDir } from './writable-dirs.mjs';
+import { MEMORY_BRIDGE_SKILL_GUIDANCE } from '../../hooks/memory_bridge.mjs';
+
+// Package skills are the skills Academy renders into an agent from its kind's
+// list. The manifest records exactly what the last render wrote, so the next
+// render can delete what left the list. It is the only ownership record: a
+// skill the manifest never named belongs to the agent and is never deleted.
+
+const PACKAGE_TEMPLATES_ROOT = join(ACADEMY_ROOT, 'templates');
+const SKILL_SURFACES = ['.claude/skills', '.agents/skills'];
+const MANIFEST_VERSION = 1;
+// A manifest entry is deleted as `<skillsDir>/<name>`. Only a plain name can
+// never resolve outside the skills dir, whatever the manifest file says.
+const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+const PACK_VERSION = JSON.parse(readFileSync(join(ACADEMY_ROOT, 'package.json'), 'utf8')).version;
+
+function packageSkillsManifestPath(dir) {
+  return join(dir, '.academy', 'generated', 'package-skills.json');
+}
+
+export function renderTemplate(template, values) {
+  const rendered = template.replace(/\{\{([a-z_]+)\}\}/g, (match, key) => {
+    if (!(key in values)) throw new Error(`Unknown template variable: ${match}`);
+    return values[key];
+  });
+  // An optional section that renders empty must not leave a hole in a surface
+  // Academy charges a token budget for.
+  return rendered.replace(/\n{3,}/g, '\n\n');
+}
+
+// Where steering goes in each agent-owned surface, for the skills that route
+// it. Surfaces absent here (local-rules and the two user files) have their own
+// skills or their own writer. Every kind routes the same set.
+const SURFACE_ROUTING = {
+  identity: `rare. Persona, voice, relationships. Update only when the
+  agent's character changes. Never method.`,
+  craft: `method, principles, definition of done, reusable domain judgment.
+  Written only by knowledge curation, in general terms, with no environment
+  names.`,
+  mandate: `the current job, scope, limits, and environment. The user writes
+  it. Propose a change; do not rewrite it.`,
+  work: `goals, priorities, focus, Workstreams, open questions. The nightly
+  run writes it. Link each Workstream by its Beads ID.`,
+  knowledge: `what the agent learned here: environment facts and raw domain
+  learning. Reusable judgment is promoted to craft.`,
+  notes: `temporary steering, observations, corrections, raw learnings,
+  pending curation. Append with \`academy notes add "..."\`; hand-edit only
+  to curate or graduate.`,
+};
+const AUTONOMOUS_SURFACES = ['work', 'notes'];
+
+function routedSurfaceNames(kind) {
+  return KIND_PROFILES[kind].surfaces
+    .map((entry) => entry.name)
+    .filter((surfaceName) => surfaceName in SURFACE_ROUTING);
+}
+
+function surfaceRoutingValues(dir, kind) {
+  const names = routedSurfaceNames(kind);
+  return {
+    surface_paths: names.map((n) => `- \`${n}.md\`: \`${join(dir, `${n}.md`)}\``).join('\n'),
+    surface_routing: names.map((n) => `- \`${n}.md\`: ${SURFACE_ROUTING[n]}`).join('\n'),
+    autonomous_surfaces: names
+      .filter((n) => AUTONOMOUS_SURFACES.includes(n))
+      .map((n) => `\`${n}.md\``)
+      .join(', '),
+  };
+}
+
+export function universalSkillValues(dir, name, skillsDir, kind) {
+  const dreamsDir = join(dir, 'dreams');
+  return {
+    ...surfaceRoutingValues(dir, kind),
+    // The shown name changes on rename; the id (the folder) never does, so
+    // Beads labels, job ids and tldr `academy_agent` render from it.
+    agent_name: name,
+    agent_id: basename(dir),
+    agent_dir: dir,
+    identity_path: join(dir, 'identity.md'),
+    craft_path: join(dir, 'craft.md'),
+    mandate_path: join(dir, 'mandate.md'),
+    work_path: join(dir, 'work.md'),
+    knowledge_path: join(dir, 'knowledge.md'),
+    notes_path: join(dir, 'notes.md'),
+    local_rules_path: join(dir, 'local-rules.md'),
+    user_path: join(ACADEMY_HOME, 'user.md'),
+    user_work_path: join(ACADEMY_HOME, 'user-work.md'),
+    proposals_dir: proposalsDir(kind),
+    pack_version: PACK_VERSION,
+    academy_home: ACADEMY_HOME,
+    memory_observations_path: join(dir, 'memory', 'observations'),
+    memory_bridge_guidance: MEMORY_BRIDGE_SKILL_GUIDANCE,
+    dreams_dir: dreamsDir,
+    report_evidence_section: NIGHTLY_REPORT_EVIDENCE.section,
+    report_consumed_field: NIGHTLY_REPORT_EVIDENCE.consumed,
+    report_changed_field: NIGHTLY_REPORT_EVIDENCE.changed,
+    report_no_change_field: NIGHTLY_REPORT_EVIDENCE.noChange,
+    skills_surface: skillsDir.endsWith(join('.agents', 'skills'))
+      ? '.agents/skills'
+      : '.claude/skills',
+    skills_dir: skillsDir,
+    check_in_path: join(skillsDir, 'check-in', 'SKILL.md'),
+    nightly_consolidation_path: join(skillsDir, 'nightly-consolidation', 'SKILL.md'),
+    knowledge_curation_path: join(skillsDir, 'knowledge-curation', 'SKILL.md'),
+    ...ownerSkillValues(dir),
+  };
+}
+
+// A kind's pack template wins over a universal one of the same name.
+function skillTemplatePath(templatesRoot, kind, skillName) {
+  const packTemplate = join(templatesRoot, 'packs', kind, skillName, 'SKILL.md');
+  if (existsSync(packTemplate)) return packTemplate;
+  return join(templatesRoot, 'skills', skillName, 'SKILL.md');
+}
+
+/** Whether a kind's skill resolves to a pack or universal template. */
+export function skillTemplateExists(kind, skillName, templatesRoot = PACKAGE_TEMPLATES_ROOT) {
+  return existsSync(skillTemplatePath(templatesRoot, kind, skillName));
+}
+
+// No manifest, or one Academy cannot read, owns nothing: deleting on a guess
+// could remove an agent-authored skill.
+function readPreviousSkills(dir) {
+  try {
+    const { skills } = JSON.parse(readFileSync(packageSkillsManifestPath(dir), 'utf8'));
+    return skills && typeof skills === 'object' ? skills : {};
+  } catch {
+    return {};
+  }
+}
+
+function staleSkills(previous, current) {
+  if (!Array.isArray(previous)) return [];
+  return previous.filter(
+    (skillName) => SKILL_NAME_RE.test(skillName) && !current.includes(skillName),
+  );
+}
+
+export function renderPackageSkills(
+  dir,
+  name,
+  { kind, skills, templatesRoot = PACKAGE_TEMPLATES_ROOT },
+) {
+  const previous = readPreviousSkills(dir);
+  const manifest = { version: MANIFEST_VERSION, kind, skills: {} };
+
+  for (const surface of SKILL_SURFACES) {
+    const skillsDir = join(dir, surface);
+    const values = universalSkillValues(dir, name, skillsDir, kind);
+    mkdirSync(skillsDir, { recursive: true });
+    for (const skillName of skills) {
+      const template = readFileSync(skillTemplatePath(templatesRoot, kind, skillName), 'utf8');
+      mkdirSync(join(skillsDir, skillName), { recursive: true });
+      writeFileSync(join(skillsDir, skillName, 'SKILL.md'), renderTemplate(template, values));
+    }
+    for (const skillName of staleSkills(previous[surface], skills)) {
+      rmSync(join(skillsDir, skillName), { recursive: true, force: true });
+    }
+    manifest.skills[surface] = [...skills];
+  }
+
+  mkdirSync(join(dir, '.academy', 'generated'), { recursive: true });
+  writeFileSync(packageSkillsManifestPath(dir), JSON.stringify(manifest, null, 2) + '\n');
+}

package/scripts/cli/start.mjs

@@ -0,0 +1,201 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { isDraftMandate, isStopped, liveJobIds, readMandate } from './agent-gate.mjs';
+import { currentAgentName } from './agent-id.mjs';
+import {
+  agentDir,
+  agentLifecycleLockPath,
+  contractOk,
+  exitJsonError,
+  kindOf,
+  withFileLock,
+} from './core.mjs';
+import { requestFirstRun } from './first-run.mjs';
+import { jobLabel, registerAcademyJobs, registeredJobIds } from './create.mjs';
+import {
+  DeleteAgentError,
+  academyJobIds,
+  assertOwnedAgentForDelete,
+  deleteAcademyJobs,
+  kindJobIds,
+  preflightOwnedAgent,
+  reportLifecycleFailure,
+  unscheduleError,
+} from './lifecycle.mjs';
+import { ownerConfig, ownerHeartbeatCron } from './owner-config.mjs';
+import { rewriteAgentYamlScalar } from './yaml.mjs';
+
+// `start` signs an agent in (decision D1): an Owner's mandate and terms are
+// checked before any write, then written with `stopped` cleared, then its jobs
+// register. Every check comes before the lock, where an exit would strand it.
+
+// The trust level a person picks, as the two Owner terms it sets.
+const TRUST_TERMS = {
+  1: { owner_gates: 'proposal, pr', owner_may_merge: 'false' },
+  2: { owner_gates: 'pr', owner_may_merge: 'false' },
+  3: { owner_gates: 'proposal', owner_may_merge: 'true' },
+  4: { owner_gates: 'none', owner_may_merge: 'true' },
+};
+
+export function startAgent(parsed) {
+  const { name, json } = parsed;
+  if (parsed.invalidOption !== undefined) {
+    refuse(
+      `Unknown start option: ${parsed.invalidOption}. Use start <name> [--mandate <file>] [--hours <h>] [--contact <c>] [--trust 1-4] [--json].`,
+      { option: parsed.invalidOption },
+      json,
+    );
+  }
+  const { id } = preflightOwnedAgent(name, json);
+  const dir = resolve(agentDir(id));
+  const kind = kindOf(dir);
+  const terms = kind === 'owner' ? ownerTerms(dir, parsed) : nonOwnerTerms(parsed, kind);
+  let jobs;
+  try {
+    jobs = withFileLock(agentLifecycleLockPath(dir), () => startLocked(dir, id, terms));
+  } catch (error) {
+    reportLifecycleFailure(error, 'start', name, json);
+  }
+  const scheduledJobIds = registeredJobIds(jobs);
+  // After the lock is released: the provider run writes its runtime scalar under it.
+  const firstRun = kind === 'owner' ? requestFirstRun(dir, id, scheduledJobIds) : null;
+  reportStarted({ name: currentAgentName(dir), kind, scheduledJobIds, firstRun }, json);
+}
+
+function refuse(message, fields, json) {
+  if (json) exitJsonError('invalid_spec', message, fields);
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}
+
+function nonOwnerTerms({ mandate, hours, contact, trust, json }, kind) {
+  if ([mandate, hours, contact, trust].some((value) => value !== undefined)) {
+    refuse(`A ${kind} takes no mandate or Owner terms. Start it with no options.`, { kind }, json);
+  }
+  return { mandate: null, scalars: {} };
+}
+
+// The new or stored mandate, hours and trust, each checked before any write.
+function ownerTerms(dir, { mandate, hours, contact, trust, json }) {
+  const text = mandate === undefined ? readMandate(dir) : readMandateFile(mandate, json);
+  if (isDraftMandate(text)) {
+    refuse(
+      'The Owner has no signed mandate. Write the mandate and pass it with --mandate <file>.',
+      { reason: 'mandate_missing' },
+      json,
+    );
+  }
+  const scalars = {};
+  const stored = ownerConfig(dir);
+  const effectiveHours = hours ?? stored.owner_hours;
+  if (!ownerHeartbeatCron(effectiveHours, stored.owner_heartbeat)) {
+    refuse(
+      `owner_hours "${effectiveHours}" with owner_heartbeat "${stored.owner_heartbeat}" is not a schedule Academy reads. Use "24x7" or "daily|weekdays HH:MM-HH:MM".`,
+      { reason: 'hours_invalid', hours: effectiveHours },
+      json,
+    );
+  }
+  if (hours !== undefined) scalars.owner_hours = `"${hours}"`;
+  if (trust !== undefined) {
+    if (!Object.hasOwn(TRUST_TERMS, trust)) {
+      refuse(
+        `--trust must be 1, 2, 3 or 4, not "${trust}".`,
+        { reason: 'trust_invalid', trust },
+        json,
+      );
+    }
+    Object.assign(scalars, TRUST_TERMS[trust]);
+  }
+  if (contact !== undefined) {
+    // One agent.yaml line: a line break would write a second key.
+    if (/[\r\n]/.test(contact) || contact.trim() === '') {
+      refuse('--contact must be one non-empty line.', { reason: 'contact_invalid' }, json);
+    }
+    scalars.owner_contact = contact.trim();
+  }
+  return { mandate: mandate === undefined ? null : text, scalars };
+}
+
+function readMandateFile(path, json) {
+  try {
+    return readFileSync(path, 'utf8');
+  } catch (error) {
+    return refuse(`Cannot read mandate file ${path}: ${error.message}`, { path }, json);
+  }
+}
+
+// The writes and the registration, under the lifecycle lock. The unlocked
+// scalar writer: `writeAgentYamlScalar` would take this same lock again.
+function startLocked(dir, id, { mandate, scalars }) {
+  assertOwnedAgentForDelete(id, dir);
+  const before = { mandate: readMandate(dir), yaml: readFileSync(join(dir, 'agent.yaml'), 'utf8') };
+  const liveBefore = liveJobIds(dir, kindJobIds(id, dir));
+  if (mandate !== null) writeFileSync(join(dir, 'mandate.md'), mandate);
+  for (const [key, value] of Object.entries(scalars)) rewriteAgentYamlScalar(dir, key, value);
+  if (isStopped(dir)) rewriteAgentYamlScalar(dir, 'stopped', 'false');
+  const jobs = registerAcademyJobs(dir, id);
+  const failed = jobs.find((job) => !job.registered && !job.skipped);
+  if (!failed) return jobs;
+  // Back to the files from before this start: the old mandate, terms and `stopped`.
+  if (mandate !== null) writeFileSync(join(dir, 'mandate.md'), before.mandate);
+  writeFileSync(join(dir, 'agent.yaml'), before.yaml);
+  const name = currentAgentName(dir);
+  const reasons = [
+    `failed to register ${jobLabel(failed.id)} "${failed.id}" for "${name}": ${failed.reason}`,
+    ...rollBackJobs(dir, id, registeredJobIds(jobs), liveBefore),
+  ];
+  throw new DeleteAgentError('runtime_unavailable', reasons.join('; '), { name, jobId: failed.id });
+}
+
+// Deletes the jobs this start added, then registers the jobs live before it
+// again from the restored files: --merge may already have changed them.
+// Returns each rollback failure as a reason.
+function rollBackJobs(dir, id, registered, liveBefore) {
+  const reasons = [];
+  const added = registered.filter((jobId) => !liveBefore.includes(jobId));
+  const deleted = added.length > 0 ? deleteAcademyJobs(dir, added) : { ok: true };
+  if (!deleted.ok) reasons.push(`rollback could not delete "${deleted.id}": ${deleted.reason}`);
+  if (liveBefore.length === 0) return reasons;
+  const again = registerAcademyJobs(dir, id).find((job) => !job.registered && !job.skipped);
+  if (again) {
+    reasons.push(
+      `rollback could not register "${again.id}" again with the old terms: ${again.reason}`,
+    );
+  }
+  return reasons;
+}
+
+function reportStarted({ name, kind, scheduledJobIds, firstRun }, json) {
+  if (json) {
+    contractOk('start', { name, kind, started: true, scheduledJobIds, firstRun });
+    return;
+  }
+  console.log(`Started agent "${name}". Jobs: ${scheduledJobIds.join(', ') || 'none'}.`);
+  if (firstRun?.status === 'requested') console.log(`Requested the first daily run.`);
+  if (firstRun?.status === 'failed') console.error(firstRun.message);
+}
+
+// `stop` writes `stopped: true` first, so a job a failed delete leaves behind
+// starts no model, then deletes every job by id. The files stay; a later
+// `stop` retries a failed delete.
+export function stopAgent(name, json) {
+  const { id, dirReal } = preflightOwnedAgent(name, json);
+  try {
+    withFileLock(agentLifecycleLockPath(agentDir(id)), () => stopLocked(dirReal, id, json));
+  } catch (error) {
+    reportLifecycleFailure(error, 'stop', name, json);
+  }
+}
+
+function stopLocked(dir, id, json) {
+  assertOwnedAgentForDelete(id, dir);
+  const name = currentAgentName(dir);
+  rewriteAgentYamlScalar(dir, 'stopped', 'true');
+  const unscheduled = deleteAcademyJobs(dir, academyJobIds(id, dir));
+  if (!unscheduled.ok) throw unscheduleError('stop', name, unscheduled);
+  // The Owner's own session jobs are deleted too, but only the jobs Academy
+  // registers are reported, the set `start` registers again.
+  const deletedJobIds = kindJobIds(id, dir);
+  if (json) contractOk('stop', { name, stopped: true, deletedJobIds });
+  else console.log(`Stopped agent "${name}". Deleted jobs: ${deletedJobIds.join(', ')}.`);
+}

package/scripts/cli/templates.mjs

@@ -1,6 +1,45 @@
+// The first line of every created file names its class: private (never copied
+// to a clone) or craft (transferable). The operating model's "Your files"
+// section states the same rule at length.
+const HEADERS = {
+  identity: 'Private: not copied to a clone. Persona and voice. No method.',
+  craft: 'Craft: transferable. Do not name a user, repo, system, person, or product.',
+  mandate: 'Private: written by the user. Your job, scope, limits, and environment.',
+  work: 'Private: written by your nightly run. Goals, priorities, focus, Workstreams.',
+  knowledge:
+    'Private: what you learned here. Move reusable judgment to craft.md through knowledge curation.',
+  notes: 'Private: temporary. Graduate each note or let it expire.',
+  'local-rules': "Private: the user's rules for you. They override package skills.",
+  user: 'Private: shared by all agents. The curator writes it. Agents add only [proposed] lines.',
+  'user-work': 'Private: shared by all agents. Only the curator writes it.',
+};
+
+// An agent's work.md and the user's user-work.md use the same sections.
+const WORK_SECTIONS = `## Goals
+
+_(An outcome to pursue, with a measure or the word "qualitative".)_
+
+## Priorities
+
+_(The order of goals and Workstreams, with the reason for each.)_
+
+## Focus
+
+_(What deserves attention now.)_
+
+## Workstreams
+
+_(One line each: Beads ID, title, state, owner. Keep the detail in Beads.)_
+
+## Open questions
+
+_(None yet.)_`;
+
 export const TEMPLATES = {
   'identity.md': (name, today) =>
-    `# Identity
+    `${HEADERS.identity}
+
+# Identity
 
 _(Who you are — values, character, voice, persona/backstory.)_
 
@@ -11,94 +50,129 @@ _(Hire flow will populate this. See \`academy hire\`.)_
 ---
 _Created: ${today}._
 `,
-  'role.md': (name, today) =>
-    `# Role
+  'craft.md': (name, today) =>
+    `${HEADERS.craft}
+
+# Craft
+
+_(How you work — discipline, method, principles, definition of done, reusable domain judgment.)_
 
-_(What you do — job, responsibilities, scope, deliverable shape, cadence.)_
+Write in general terms. After creation, text enters this file only through knowledge curation.
 
 _(Hire flow will populate this. See \`academy hire\`.)_
 
 ---
 _Created: ${today}._
 `,
-  'knowledge.md': (name, today) =>
-    `# Knowledge
+  'mandate.md': (name, today) =>
+    `${HEADERS.mandate}
 
-_(What you know — domain expertise, mental models, frameworks, learned patterns.)_
+# Mandate
 
-Lightweight sections by domain (max 5–8). Dated entries within sections.
-Curation is by reference + uniqueness + user signal — see scope §7.
+_(Your current job — scope, limits, and the environment you work in: repos, systems, people, products.)_
 
-_(Hire flow will populate this from research. See \`academy hire\`.)_
+_(Hire flow will populate this. See \`academy hire\`.)_
 
 ---
 _Created: ${today}._
 `,
-  'goals.md': (name, today) =>
-    `# Goals
+  'work.md': (name, today) =>
+    `${HEADERS.work}
 
-_(Strategic direction — quarterly horizon, hard cap of 3.)_
+# Work
 
-1. _(goal one)_
-2. _(goal two)_
-3. _(goal three)_
+${WORK_SECTIONS}
 
 ---
-_Created: ${today}. Re-affirm every 14 days._
+_Created: ${today}._
 `,
-  'priorities.md': (name, today) =>
-    `# Priorities
+  'knowledge.md': (name, today) =>
+    `${HEADERS.knowledge}
 
-_(Weekly direction — WIP-limited, 3–5 visible.)_
+# Knowledge
 
-- _(priority one)_
-- _(priority two)_
+_(What you know here — environment facts, domain expertise, learned patterns.)_
+
+Lightweight sections by domain (max 5–8). Dated entries within sections.
+Curation is by reference, uniqueness, and user signal.
+
+_(Hire flow will populate this from research. See \`academy hire\`.)_
 
 ---
 _Created: ${today}._
 `,
-  'threads.md': (name, today) =>
-    `# Threads
+  'notes.md': (name, today) =>
+    `${HEADERS.notes}
+
+# Notes
 
-_(Active work pursuits — 5 active visible / 8 idle. Auto-demote by \`last_touched\`.)_
+_(Micro-steering staging area. No daytime limit. Must be at 500 after each nightly: graduate or expire.)_
 
-## Active
+_Capture temporary steering, corrections, stakeholder facts, caveats, and raw
+learnings here with_ \`academy notes add "..."\` _— it appends a timestamped
+bullet without rewriting this file. Review with_ \`academy notes list\`_._
 
 _(none yet)_
 
-## Idle
+---
+_Created: ${today}. Long-staying notes are a smell — they should graduate to knowledge, work, craft, or a skill, or expire._
+`,
+  'local-rules.md': (name, today) =>
+    `${HEADERS['local-rules']}
 
-_(none yet)_
+# Local Rules
 
-## Parked
+_(Your user's rules for how you work. Each one overrides any package skill
+instruction. Write and edit them with the local-rules skill.)_
+
+_Entry format:_
+
+\`\`\`
+## <rule text>
+- Source: "<the user's message, quoted>"
+- Date: <YYYY-MM-DD>
+- Pack version: <Academy version when written>
+\`\`\`
 
 _(none yet)_
 
 ---
 _Created: ${today}._
 `,
-  'notes.md': (name, today) =>
-    `# Notes
+  // The two shared surfaces under ACADEMY_HOME. One file each for the user, so
+  // they carry no agent name. user.md grammar: `##` groups, `###` labels, `-`
+  // statements. Its last section is Proposed, because `academy notes add --user`
+  // appends one line at the end of the file.
+  'user.md': () =>
+    `${HEADERS.user}
 
-_(Micro-steering staging area — 8–12 visible cap. Graduate or expire.)_
+# User
 
-_Capture temporary steering, corrections, stakeholder facts, caveats, and raw
-learnings here with_ \`academy notes add "..."\` _— it appends a timestamped
-bullet without rewriting this file. Review with_ \`academy notes list\`_._
+## Identity
+- _(Who the user is, what the user does and owns, how and when the user works.)_
 
-_(none yet)_
+## Preferences
+### Answers
+- _(How the user wants answers, plans, and reports written.)_
+### Changes
+- _(What the user wants asked first, and what to just do.)_
 
----
-_Created: ${today}. Long-staying notes are a smell — they should graduate to knowledge / role / identity / skill, or expire._
-`,
-  'dailys.md': (name, today) =>
-    `# Recent Days
+## Feed
+- _(Last 7 days. Promote or drop each item weekly.)_
 
-_(Tight summaries, last 7 working days, FIFO.)_
+## Scoped rules
+- _(A rule the user set for some agents or one project.)_
 
-_(none yet — populated by daily primitive in Phase 3.)_
+## Projects
+- _(The lead agent for each project. Details are in user-work.md.)_
 
----
-_Created: ${today}._
+## Proposed
+`,
+  'user-work.md': () =>
+    `${HEADERS['user-work']}
+
+# User work
+
+${WORK_SECTIONS}
 `,
 };