waypoint-codex 0.8.1 → 0.9.1

package/README.md

@@ -28,6 +28,7 @@ Waypoint scaffolds a Codex-friendly repo structure built around a few core piece
 - `.waypoint/TRACKS_INDEX.md` for tracker routing
 - `.waypoint/context/` for generated startup context
 - `.agents/skills/` for repo-local workflows like planning, tracking, audits, and QA
+- `.codex/` for the default reviewer-agent pack
 
 The philosophy is simple:
 
@@ -66,7 +67,7 @@ npx waypoint-codex@latest --help
 Inside the repo you want to prepare for Codex:
 
 ```bash
-waypoint init --with-roles --with-automations
+waypoint init
 waypoint doctor
 ```
 
@@ -75,6 +76,9 @@ That gives you a repo that looks roughly like this:
 ```text
 repo/
 ├── AGENTS.md
+├── .codex/
+│   ├── agents/
+│   └── config.toml
 ├── .agents/
 │   └── skills/
 └── .waypoint/
@@ -98,39 +102,29 @@ From there, start your Codex session in the repo and follow the generated bootst
 waypoint init
 ```
 
-By default, `waypoint init` updates the global CLI to the latest published `waypoint-codex` first, then scaffolds with that fresh version. If you want to scaffold with the currently installed binary instead, use:
+By default, `waypoint init` updates the global CLI to the latest published `waypoint-codex` first, then scaffolds with that fresh version. It also installs the reviewer-agent pack by default. If you want to scaffold with the currently installed binary instead, use:
 
 ```bash
 waypoint init --skip-cli-update
 ```
 
-### Full local workflow setup
-
-```bash
-waypoint init --with-roles --with-rules --with-automations
-```
-
 ### App-friendly profile
 
 ```bash
-waypoint init --app-friendly --with-roles --with-automations
+waypoint init --app-friendly
 ```
 
 Flags you can combine:
 
 - `--app-friendly`
-- `--with-roles`
-- `--with-rules`
-- `--with-automations`
 - `--skip-cli-update`
 
 ## Main commands
 
 - `waypoint init` — update the CLI to latest by default, then scaffold or refresh the repo
 - `waypoint doctor` — validate health and report drift
-- `waypoint sync` — rebuild the docs index and sync optional user-home artifacts
+- `waypoint sync` — rebuild the docs and tracker indexes
 - `waypoint upgrade` — update the CLI and refresh the current repo using its saved config
-- `waypoint import-legacy` — analyze an older repo layout and produce an adoption report
 
 ## Built-in skills
 
@@ -141,21 +135,24 @@ Waypoint ships a strong default skill pack for real coding work:
 - `docs-sync`
 - `code-guide-audit`
 - `break-it-qa`
+- `frontend-ship-audit`
+- `backend-ship-audit`
 - `workspace-compress`
 - `pre-pr-hygiene`
 - `pr-review`
 
 These are repo-local, so the workflow travels with the project.
+`break-it-qa`, `frontend-ship-audit`, and `backend-ship-audit` are user-invoked audit skills, not default autonomous agent steps.
 
-## Optional reviewer roles
+## Reviewer agents
 
-If you initialize with `--with-roles`, Waypoint scaffolds:
+Waypoint scaffolds these reviewer agents by default:
 
 - `code-health-reviewer`
 - `code-reviewer`
 - `plan-reviewer`
 
-The intended workflow is chunk-based: once there is a meaningful reviewable slice, run the reviewers in parallel, fix real findings, then close out. A recent self-authored commit is the preferred scope anchor when one cleanly represents the slice, but it is not the only valid trigger.
+The intended workflow is closeout-based: run `code-reviewer` before considering any non-trivial implementation slice complete, and run `code-health-reviewer` before considering medium or large changes complete, especially when they add structure, duplicate logic, or introduce new abstractions. If both apply, run them in parallel. A recent self-authored commit is the preferred scope anchor when one cleanly represents the slice, but it is not the only valid trigger.
 
 ## What makes it different
 
@@ -185,22 +182,11 @@ If you only want to update the CLI:
 waypoint upgrade --skip-repo-refresh
 ```
 
-## Importing an existing repo
-
-If you already have an older assistant setup or repo-memory system:
-
-```bash
-waypoint import-legacy /path/to/source-repo /path/to/new-repo --init-target
-```
-
-This generates an adoption report and helps separate durable docs from old runtime-specific scaffolding.
-
 ## Learn more
 
 - [Overview](docs/overview.md)
 - [Architecture](docs/architecture.md)
 - [Upgrading](docs/upgrading.md)
-- [Importing Existing Repositories](docs/importing-existing-repos.md)
 - [Releasing](docs/releasing.md)
 
 ## License

package/dist/src/cli.js

@@ -4,7 +4,7 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import process from "node:process";
-import { doctorRepository, importLegacyRepo, initRepository, loadWaypointConfig, syncRepository } from "./core.js";
+import { doctorRepository, initRepository, loadWaypointConfig, syncRepository } from "./core.js";
 import { maybeUpgradeWaypointBeforeInit, upgradeWaypoint } from "./upgrade.js";
 const VERSION = JSON.parse(readFileSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json"), "utf8")).version;
 function resolveRepo(input) {
@@ -29,9 +29,8 @@ function printHelp() {
 Commands:
   init                Initialize a repository with Waypoint scaffolding (auto-updates CLI unless skipped)
   doctor              Validate repository health and report drift
-  sync                Rebuild docs index and sync optional user-home artifacts
+  sync                Rebuild docs and tracker indexes
   upgrade             Update the global Waypoint CLI and refresh this repo using existing config
-  import-legacy       Analyze a legacy repository layout and produce a Waypoint adoption report
 `);
 }
 async function main() {
@@ -50,9 +49,6 @@ async function main() {
             args: argv.slice(1),
             options: {
                 "app-friendly": { type: "boolean", default: false },
-                "with-roles": { type: "boolean", default: false },
-                "with-rules": { type: "boolean", default: false },
-                "with-automations": { type: "boolean", default: false },
                 "skip-cli-update": { type: "boolean", default: false }
             },
             allowPositionals: true
@@ -70,9 +66,6 @@ async function main() {
         }
         const results = initRepository(projectRoot, {
             profile: values["app-friendly"] ? "app-friendly" : "universal",
-            withRoles: values["with-roles"],
-            withRules: values["with-rules"],
-            withAutomations: values["with-automations"]
         });
         for (const line of results) {
             console.log(`- ${line}`);
@@ -116,31 +109,6 @@ async function main() {
         }
         return 0;
     }
-    if (command === "import-legacy") {
-        const { values, positionals } = parseArgs({
-            args: argv.slice(1),
-            options: {
-                "init-target": { type: "boolean", default: false }
-            },
-            allowPositionals: true
-        });
-        if (positionals.length === 0) {
-            console.error("import-legacy requires a source repository path.");
-            return 2;
-        }
-        const sourceRepo = resolveRepo(positionals[0]);
-        const targetRepo = positionals[1] ? resolveRepo(positionals[1]) : undefined;
-        const result = importLegacyRepo(sourceRepo, targetRepo, {
-            initTarget: values["init-target"]
-        });
-        for (const line of result.actions) {
-            console.log(`- ${line}`);
-        }
-        if (!targetRepo) {
-            console.log(result.report);
-        }
-        return 0;
-    }
     if (command === "upgrade") {
         const { values, positionals } = parseArgs({
             args: argv.slice(1),

package/dist/src/core.js

@@ -1,6 +1,4 @@
-import { createHash } from "node:crypto";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import os from "node:os";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import * as TOML from "@iarna/toml";
 import { renderDocsIndex } from "./docs-index.js";
@@ -12,8 +10,6 @@ const DEFAULT_DOCS_INDEX = ".waypoint/DOCS_INDEX.md";
 const DEFAULT_TRACK_DIR = ".waypoint/track";
 const DEFAULT_TRACKS_INDEX = ".waypoint/TRACKS_INDEX.md";
 const DEFAULT_WORKSPACE = ".waypoint/WORKSPACE.md";
-const STATE_DIR = ".waypoint/state";
-const SYNC_RECORDS_FILE = ".waypoint/state/sync-records.json";
 const TIMESTAMPED_WORKSPACE_SECTIONS = new Set([
     "## Active Trackers",
     "## Current State",
@@ -101,9 +97,6 @@ function scaffoldSkills(projectRoot) {
     copyTemplateTree(templatePath(".agents/skills"), targetRoot);
 }
 function scaffoldWaypointOptionalTemplates(projectRoot) {
-    copyTemplateTree(templatePath(".waypoint/agents"), path.join(projectRoot, ".waypoint/agents"));
-    copyTemplateTree(templatePath(".waypoint/automations"), path.join(projectRoot, ".waypoint/automations"));
-    copyTemplateTree(templatePath(".waypoint/rules"), path.join(projectRoot, ".waypoint/rules"));
     copyTemplateTree(templatePath(".waypoint/scripts"), path.join(projectRoot, ".waypoint/scripts"));
     copyTemplateTree(templatePath(".waypoint/track"), path.join(projectRoot, ".waypoint/track"));
 }
@@ -135,21 +128,18 @@ export function initRepository(projectRoot, options) {
         ".codex/agents/reviewer.toml",
         ".codex/agents/architect.toml",
         ".codex/agents/implementer.toml",
+        ".waypoint/automations",
+        ".waypoint/rules",
+        ".waypoint/state",
     ]) {
         removePathIfExists(path.join(projectRoot, deprecatedPath));
     }
-    ensureDir(path.join(projectRoot, ".waypoint/automations"));
-    ensureDir(path.join(projectRoot, ".waypoint/rules"));
-    ensureDir(path.join(projectRoot, STATE_DIR));
     writeText(path.join(projectRoot, ".waypoint/README.md"), readTemplate(".waypoint/README.md"));
     writeText(path.join(projectRoot, ".waypoint/SOUL.md"), readTemplate(".waypoint/SOUL.md"));
     writeText(path.join(projectRoot, ".waypoint/agent-operating-manual.md"), readTemplate(".waypoint/agent-operating-manual.md"));
     scaffoldWaypointOptionalTemplates(projectRoot);
     writeText(path.join(projectRoot, DEFAULT_CONFIG_PATH), renderWaypointConfig({
         profile: options.profile,
-        roles: options.withRoles,
-        rules: options.withRules,
-        automations: options.withAutomations,
     }));
     writeIfMissing(path.join(projectRoot, DEFAULT_WORKSPACE), readTemplate("WORKSPACE.md"));
     ensureDir(path.join(projectRoot, DEFAULT_DOCS_DIR));
@@ -158,9 +148,7 @@ export function initRepository(projectRoot, options) {
     writeIfMissing(path.join(projectRoot, ".waypoint/docs/code-guide.md"), readTemplate(".waypoint/docs/code-guide.md"));
     upsertManagedBlock(path.join(projectRoot, "AGENTS.md"), readTemplate("managed-agents-block.md"));
     scaffoldSkills(projectRoot);
-    if (options.withRoles) {
-        scaffoldOptionalCodex(projectRoot);
-    }
+    scaffoldOptionalCodex(projectRoot);
     appendGitignoreSnippet(projectRoot);
     const docsIndex = renderDocsIndex(projectRoot, path.join(projectRoot, DEFAULT_DOCS_DIR));
     const tracksIndex = renderTracksIndex(projectRoot, path.join(projectRoot, DEFAULT_TRACK_DIR));
@@ -171,6 +159,7 @@ export function initRepository(projectRoot, options) {
         "Installed managed AGENTS block",
         "Created .waypoint/WORKSPACE.md, .waypoint/docs/, and .waypoint/track/ scaffold",
         "Installed repo-local Waypoint skills",
+        "Installed reviewer agents and project Codex config",
         "Generated .waypoint/DOCS_INDEX.md and .waypoint/TRACKS_INDEX.md",
     ];
 }
@@ -181,27 +170,6 @@ export function loadWaypointConfig(projectRoot) {
     }
     return TOML.parse(readFileSync(configPath, "utf8"));
 }
-function loadSyncRecords(projectRoot) {
-    const syncPath = path.join(projectRoot, SYNC_RECORDS_FILE);
-    if (!existsSync(syncPath)) {
-        return {};
-    }
-    try {
-        return JSON.parse(readFileSync(syncPath, "utf8"));
-    }
-    catch {
-        return {};
-    }
-}
-function saveSyncRecords(projectRoot, records) {
-    writeText(path.join(projectRoot, SYNC_RECORDS_FILE), `${JSON.stringify(records, null, 2)}\n`);
-}
-function hashFile(filePath) {
-    return createHash("sha256").update(readFileSync(filePath)).digest("hex");
-}
-function codexHome() {
-    return process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
-}
 function findWorkspaceTimestampViolations(workspaceText) {
     let currentSection = "";
     const violations = new Set();
@@ -223,111 +191,6 @@ function findWorkspaceTimestampViolations(workspaceText) {
     }
     return [...violations];
 }
-function renderCodexAutomation(spec, cwd) {
-    const now = Date.now();
-    const rrule = spec.rrule?.startsWith("RRULE:") ? spec.rrule : `RRULE:${spec.rrule}`;
-    return [
-        "version = 1",
-        `id = ${JSON.stringify(spec.id)}`,
-        `name = ${JSON.stringify(spec.name)}`,
-        `prompt = ${JSON.stringify(spec.prompt)}`,
-        `status = ${JSON.stringify(spec.status ?? "ACTIVE")}`,
-        `rrule = ${JSON.stringify(rrule)}`,
-        `execution_environment = ${JSON.stringify(spec.execution_environment ?? "worktree")}`,
-        `cwds = ${JSON.stringify(spec.cwds ?? [cwd])}`,
-        `created_at = ${now}`,
-        `updated_at = ${now}`,
-    ].join("\n") + "\n";
-}
-function isKebabCase(value) {
-    return /^[a-z0-9-]+$/.test(value);
-}
-function validateAutomationSpecFile(filePath) {
-    const errors = [];
-    let parsed;
-    try {
-        parsed = TOML.parse(readFileSync(filePath, "utf8"));
-    }
-    catch (error) {
-        return [`invalid TOML: ${error instanceof Error ? error.message : String(error)}`];
-    }
-    for (const key of ["id", "name", "prompt", "rrule"]) {
-        if (!parsed[key]) {
-            errors.push(`missing required key \`${key}\``);
-        }
-    }
-    if (parsed.id && !isKebabCase(parsed.id)) {
-        errors.push("automation id must use lowercase kebab-case");
-    }
-    return errors;
-}
-function syncAutomations(projectRoot) {
-    const sourceDir = path.join(projectRoot, ".waypoint/automations");
-    if (!existsSync(sourceDir)) {
-        return [];
-    }
-    const targetRoot = path.join(codexHome(), "automations");
-    ensureDir(targetRoot);
-    const records = loadSyncRecords(projectRoot);
-    const results = [];
-    for (const entry of readdirSync(sourceDir)) {
-        if (!entry.endsWith(".toml")) {
-            continue;
-        }
-        const sourcePath = path.join(sourceDir, entry);
-        const errors = validateAutomationSpecFile(sourcePath);
-        if (errors.length > 0) {
-            results.push(`Skipped ${entry}: ${errors.join("; ")}`);
-            continue;
-        }
-        const spec = TOML.parse(readFileSync(sourcePath, "utf8"));
-        if (spec.enabled === false) {
-            continue;
-        }
-        const targetDir = path.join(targetRoot, spec.id);
-        const targetPath = path.join(targetDir, "automation.toml");
-        ensureDir(targetDir);
-        writeText(targetPath, renderCodexAutomation(spec, projectRoot));
-        records[sourcePath] = {
-            artifact_type: "automation",
-            source_path: sourcePath,
-            target_path: targetPath,
-            source_hash: hashFile(sourcePath),
-            target_hash: hashFile(targetPath),
-        };
-        results.push(`Synced automation \`${spec.id}\``);
-    }
-    saveSyncRecords(projectRoot, records);
-    return results;
-}
-function syncRules(projectRoot) {
-    const sourceDir = path.join(projectRoot, ".waypoint/rules");
-    if (!existsSync(sourceDir)) {
-        return [];
-    }
-    const targetRoot = path.join(codexHome(), "rules");
-    ensureDir(targetRoot);
-    const records = loadSyncRecords(projectRoot);
-    const results = [];
-    for (const entry of readdirSync(sourceDir)) {
-        if (!entry.endsWith(".rules")) {
-            continue;
-        }
-        const sourcePath = path.join(sourceDir, entry);
-        const targetPath = path.join(targetRoot, `waypoint-${entry}`);
-        copyFileSync(sourcePath, targetPath);
-        records[sourcePath] = {
-            artifact_type: "rules",
-            source_path: sourcePath,
-            target_path: targetPath,
-            source_hash: hashFile(sourcePath),
-            target_hash: hashFile(targetPath),
-        };
-        results.push(`Synced rules \`${entry}\``);
-    }
-    saveSyncRecords(projectRoot, records);
-    return results;
-}
 export function doctorRepository(projectRoot) {
     const findings = [];
     const config = loadWaypointConfig(projectRoot);
@@ -532,55 +395,15 @@ export function doctorRepository(projectRoot) {
             });
         }
     }
-    const featureMap = config.features ?? {};
-    if (featureMap.automations) {
-        const records = loadSyncRecords(projectRoot);
-        const automationDir = path.join(projectRoot, ".waypoint/automations");
-        if (existsSync(automationDir)) {
-            for (const entry of readdirSync(automationDir)) {
-                if (!entry.endsWith(".toml")) {
-                    continue;
-                }
-                const filePath = path.join(automationDir, entry);
-                const errors = validateAutomationSpecFile(filePath);
-                for (const error of errors) {
-                    findings.push({
-                        severity: "error",
-                        category: "automations",
-                        message: `${path.relative(projectRoot, filePath)}: ${error}`,
-                        remediation: "Fix the automation spec and rerun `waypoint sync`.",
-                        paths: [filePath],
-                    });
-                }
-                if (errors.length === 0) {
-                    const spec = TOML.parse(readFileSync(filePath, "utf8"));
-                    if (spec.enabled === false) {
-                        continue;
-                    }
-                }
-                if (errors.length === 0 && !records[filePath]) {
-                    findings.push({
-                        severity: "info",
-                        category: "automations",
-                        message: `Automation \`${path.basename(entry, ".toml")}\` has not been synced.`,
-                        remediation: "Run `waypoint sync` to install it into Codex home.",
-                        paths: [filePath],
-                    });
-                }
-            }
-        }
-    }
-    if (featureMap.roles) {
-        const codexConfigPath = path.join(projectRoot, ".codex/config.toml");
-        if (!existsSync(codexConfigPath)) {
-            findings.push({
-                severity: "warn",
-                category: "roles",
-                message: "Role support is enabled but .codex/config.toml is missing.",
-                remediation: "Run `waypoint init --with-roles` or create the project Codex config files.",
-                paths: [codexConfigPath],
-            });
-        }
+    const codexConfigPath = path.join(projectRoot, ".codex/config.toml");
+    if (!existsSync(codexConfigPath)) {
+        findings.push({
+            severity: "warn",
+            category: "roles",
+            message: "Reviewer agent config is missing from .codex/config.toml.",
+            remediation: "Run `waypoint init` or create the project Codex config files.",
+            paths: [codexConfigPath],
+        });
     }
     return findings;
 }
@@ -594,136 +417,5 @@ export function syncRepository(projectRoot) {
     const tracksIndex = renderTracksIndex(projectRoot, trackDir);
     writeText(docsIndexPath, `${docsIndex.content}\n`);
     writeText(tracksIndexPath, `${tracksIndex.content}\n`);
-    const results = ["Rebuilt .waypoint/DOCS_INDEX.md", "Rebuilt .waypoint/TRACKS_INDEX.md"];
-    const featureMap = config.features ?? {};
-    if (featureMap.rules) {
-        results.push(...syncRules(projectRoot));
-    }
-    if (featureMap.automations) {
-        results.push(...syncAutomations(projectRoot));
-    }
-    return results;
-}
-export function importLegacyRepo(sourceRepo, targetRepo, options = {}) {
-    const sourceDocsDir = path.join(sourceRepo, ".meridian/docs");
-    const sourceSkillsDir = path.join(sourceRepo, "skills");
-    const sourceCommandsDir = path.join(sourceRepo, "commands");
-    const sourceAgentsDir = path.join(sourceRepo, "agents");
-    const sourceHooksPath = path.join(sourceRepo, "hooks/hooks.json");
-    const sourceScriptsDir = path.join(sourceRepo, "scripts");
-    const portableDocs = existsSync(sourceDocsDir)
-        ? readdirSync(sourceDocsDir).filter((entry) => entry.endsWith(".md")).sort()
-        : [];
-    const portableSkills = existsSync(sourceSkillsDir)
-        ? readdirSync(sourceSkillsDir)
-            .map((entry) => path.join("skills", entry, "SKILL.md"))
-            .filter((relPath) => existsSync(path.join(sourceRepo, relPath)))
-            .sort()
-        : [];
-    const portableCommands = existsSync(sourceCommandsDir)
-        ? readdirSync(sourceCommandsDir)
-            .filter((entry) => entry.endsWith(".md"))
-            .map((entry) => path.join("commands", entry))
-            .sort()
-        : [];
-    const agentFiles = existsSync(sourceAgentsDir)
-        ? readdirSync(sourceAgentsDir)
-            .filter((entry) => entry.endsWith(".md"))
-            .map((entry) => path.join("agents", entry))
-            .sort()
-        : [];
-    const hookFiles = existsSync(sourceHooksPath) ? [path.join("hooks", "hooks.json")] : [];
-    const scriptFiles = existsSync(sourceScriptsDir)
-        ? collectFiles(sourceScriptsDir)
-            .filter((filePath) => filePath.endsWith(".py"))
-            .map((filePath) => path.relative(sourceRepo, filePath))
-            .sort()
-        : [];
-    const actions = [];
-    if (targetRepo && options.initTarget) {
-        actions.push(...initRepository(targetRepo, {
-            profile: "universal",
-            withRoles: false,
-            withRules: false,
-            withAutomations: false,
-        }));
-    }
-    if (targetRepo) {
-        const importDir = path.join(targetRepo, ".waypoint/docs/legacy-import");
-        ensureDir(importDir);
-        for (const docName of portableDocs) {
-            copyFileSync(path.join(sourceDocsDir, docName), path.join(importDir, docName));
-        }
-        if (portableDocs.length > 0) {
-            actions.push(`Copied ${portableDocs.length} legacy docs into ${importDir}`);
-        }
-        const docsIndex = renderDocsIndex(targetRepo, path.join(targetRepo, DEFAULT_DOCS_DIR));
-        writeText(path.join(targetRepo, DEFAULT_DOCS_INDEX), `${docsIndex.content}\n`);
-    }
-    const report = [
-        "# Legacy Repository Adoption Report",
-        "",
-        `Source: \`${sourceRepo}\``,
-        "",
-        "## Portable as-is or with light rewriting",
-        "",
-        `- Docs: ${portableDocs.length}`,
-        `- Skills: ${portableSkills.length}`,
-        `- Commands/prompts worth reviewing for skill conversion: ${portableCommands.length}`,
-        "",
-        "### Docs",
-        ...(portableDocs.length > 0
-            ? portableDocs.map((entry) => `- \`.meridian/docs/${entry}\``)
-            : ["- None"]),
-        "",
-        "### Skills",
-        ...(portableSkills.length > 0 ? portableSkills.map((entry) => `- \`${entry}\``) : ["- None"]),
-        "",
-        "## Replace with explicit Waypoint patterns",
-        "",
-        "- hook-based session injection -> AGENTS routing, context generation, repo-local skills, doctor/sync",
-        "- hidden stop-hook policing -> advisory workflow skills and visible repo state",
-        "- transcript learners -> maintenance skills and optional app automations",
-        "- opaque reviewer plumbing -> optional Codex roles where actually useful",
-        "",
-        "## Legacy machinery to drop",
-        "",
-        `- Hook registration files: ${hookFiles.length}`,
-        `- Hook/runtime scripts: ${scriptFiles.length}`,
-        "",
-        "### Hook/runtime files",
-        ...((hookFiles.length + scriptFiles.length) > 0
-            ? [...hookFiles, ...scriptFiles].map((entry) => `- \`${entry}\``)
-            : ["- None"]),
-        "",
-        "## Agent files to reinterpret, not port literally",
-        "",
-        ...(agentFiles.length > 0 ? agentFiles.map((entry) => `- \`${entry}\``) : ["- None"]),
-        "",
-        "## Notes",
-        "",
-        "- The strongest reusable assets are methodology, docs patterns, and review/planning discipline.",
-        "- The weakest portability surface is hook-dependent session machinery and transcript-coupled automation.",
-        "",
-    ].join("\n");
-    if (targetRepo) {
-        const reportPath = path.join(targetRepo, ".waypoint/IMPORT_LEGACY.md");
-        writeText(reportPath, report);
-        actions.push(`Wrote migration report to ${reportPath}`);
-    }
-    return { report, actions };
-}
-function collectFiles(rootDir) {
-    const output = [];
-    for (const entry of readdirSync(rootDir)) {
-        const fullPath = path.join(rootDir, entry);
-        const stat = statSync(fullPath);
-        if (stat.isDirectory()) {
-            output.push(...collectFiles(fullPath));
-        }
-        else {
-            output.push(fullPath);
-        }
-    }
-    return output;
+    return ["Rebuilt .waypoint/DOCS_INDEX.md", "Rebuilt .waypoint/TRACKS_INDEX.md"];
 }

package/dist/src/templates.js

@@ -27,8 +27,5 @@ export function readTemplate(relativePath) {
 }
 export function renderWaypointConfig(options) {
     return readTemplate(".waypoint/config.toml")
-        .replace("__PROFILE__", options.profile)
-        .replace("__ROLES__", String(options.roles))
-        .replace("__RULES__", String(options.rules))
-        .replace("__AUTOMATIONS__", String(options.automations));
+        .replace("__PROFILE__", options.profile);
 }

package/dist/src/upgrade.js

@@ -9,16 +9,6 @@ export function buildInitArgs(projectRoot, config) {
     if (config.profile === "app-friendly") {
         args.push("--app-friendly");
     }
-    const featureMap = config.features ?? {};
-    if (featureMap.roles) {
-        args.push("--with-roles");
-    }
-    if (featureMap.rules) {
-        args.push("--with-rules");
-    }
-    if (featureMap.automations) {
-        args.push("--with-automations");
-    }
     return args;
 }
 function parseVersion(version) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waypoint-codex",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "description": "Codex-native repository operating system: scaffolding, docs routing, repo-local skills, doctor, and sync.",
   "license": "MIT",
   "type": "module",