@delegance/claude-autopilot 7.6.0 → 7.7.0

package/CHANGELOG.md

@@ -2,6 +2,55 @@
 
 - v5.6 Phase 7 (docs reconciliation) — pending.
 
+## 7.7.0 (2026-05-11)
+
+**v7.7.0 — Rust scaffold support.** Minor release. Promotes Rust from
+"detected-but-unsupported" (exit 3 in v7.4–v7.6) to a first-class
+scaffold target, matching the Node + Python + FastAPI + Go shape.
+
+**New:** `claude-autopilot scaffold --from-spec <spec.md> --stack rust`
+(or auto-detected when the spec's `## Files` section lists `Cargo.toml`,
+`src/main.rs`, or `src/lib.rs`).
+
+**Lib-vs-bin fork.** Rust adds a fork the Go scaffolder doesn't need:
+
+- spec lists ONLY `src/lib.rs` (no main.rs) → **library crate**
+  (`src/lib.rs` with a public `hello()` + inline `#[cfg(test)] mod tests`,
+  Cargo.lock added to `.gitignore`)
+- spec lists `src/main.rs` (with or without lib.rs) → **binary crate**
+  (`src/main.rs` with `println!` + `tests/integration_test.rs` smoke
+  test, Cargo.lock NOT in `.gitignore`)
+- spec lists BOTH → **mixed mode** (both targets generated; Cargo.lock
+  excluded since the binary target wins per Cargo's documented convention)
+- spec hints neither → defaults to binary (matches `cargo init` default)
+
+**Cargo.lock heuristic.** Library-only crates omit `Cargo.lock` from the
+commit per Cargo docs; binary + mixed crates commit it. The Rust
+scaffolder's `.gitignore` augmentation reflects this — `target/` is
+always added; `Cargo.lock` is added only when the spec resolves to
+library-only.
+
+**Crate name normalization.** Cargo identifiers are `[a-z0-9_]` only and
+must not start with a digit. The scaffolder lowercases `basename(cwd)`,
+replaces any non-allowed char with `_`, collapses underscore runs, and
+prefixes `_` when the result starts with a digit. Examples: `my-pkg-2`
+→ `my_pkg_2`, `2cool` → `_2cool`, `My App` → `my_app`, `foo.bar` →
+`foo_bar`.
+
+**Never overwrites.** `Cargo.toml`, `src/main.rs`, `src/lib.rs`, and
+`tests/integration_test.rs` are preserved if they already exist — matches
+the Go + Python scaffolder pattern.
+
+**Polyglot detection.** `detectStack()` now includes Rust signals
+(`Cargo.toml` / `src/main.rs` / `src/lib.rs`) in the polyglot count. So
+e.g. `package.json` + `Cargo.toml` together correctly fail-loud with
+`polyglot spec — pass --stack to disambiguate` instead of silently
+picking one.
+
+**`--list-stacks`** now shows Rust under Supported and drops it from
+Recognized-but-unsupported. Ruby remains the lone detection-only stack
+(would detect via `Gemfile`).
+
 ## 7.6.0 (2026-05-10)
 
 **v7.6.0 — Go scaffold support.** Minor release. Promotes Go from

package/dist/src/cli/help-text.js

@@ -28,7 +28,7 @@ export const HELP_GROUPS = [
         verbs: [
             { verb: 'init', summary: 'Scaffold guardrail.config.yaml + auto-detect migrate stack (writes .autopilot/stack.md)' },
             { verb: 'setup', summary: 'Auto-detect stack, write config, install pre-push hook' },
-            { verb: 'scaffold', summary: 'Scaffold project skeleton from a spec markdown (--from-spec <path> [--stack node|python|fastapi|go])' },
+            { verb: 'scaffold', summary: 'Scaffold project skeleton from a spec markdown (--from-spec <path> [--stack node|python|fastapi|go|rust])' },
             { verb: 'autopilot', summary: 'Multi-phase orchestrator — run scan → spec → plan → implement under one runId (v6.2.0)' },
             { verb: 'brainstorm', summary: 'Pipeline entry point (Claude Code skill — see /brainstorm)' },
             { verb: 'spec', summary: 'Spec-writing pointer (Claude Code skill — see /brainstorm)' },

package/dist/src/cli/index.js

@@ -935,6 +935,7 @@ switch (subcommand) {
         // v7.2.0 — `claude-autopilot scaffold --from-spec <path>`
         // v7.4.0 — `--stack <node|python|fastapi>` + `--list-stacks`.
         // v7.6.0 — `--stack go`.
+        // v7.7.0 — `--stack rust`.
         if (boolFlag('list-stacks')) {
             const { printStackList } = await import("./scaffold.js");
             printStackList();
@@ -943,8 +944,8 @@ switch (subcommand) {
         const fromSpec = flag('from-spec');
         const dryRun = boolFlag('dry-run');
         const stackArg = flag('stack');
-        if (stackArg && !['node', 'python', 'fastapi', 'go'].includes(stackArg)) {
-            console.error(`\x1b[31m[claude-autopilot] --stack "${stackArg}" not recognized — supported: node, python, fastapi, go\x1b[0m`);
+        if (stackArg && !['node', 'python', 'fastapi', 'go', 'rust'].includes(stackArg)) {
+            console.error(`\x1b[31m[claude-autopilot] --stack "${stackArg}" not recognized — supported: node, python, fastapi, go, rust\x1b[0m`);
             console.error(`  See: claude-autopilot scaffold --list-stacks`);
             process.exit(3);
         }

package/dist/src/cli/scaffold/rust.d.ts

@@ -0,0 +1,38 @@
+import type { ScaffoldResult, ScaffoldRunContext } from './types.ts';
+/**
+ * Normalize a basename into a valid Cargo crate name.
+ *
+ * Cargo identifiers: `[a-z0-9_]` only, must not start with a digit.
+ *
+ * - lowercased
+ * - any char outside `[a-z0-9_]` collapses to `_`
+ * - repeated `_` runs collapse to a single `_`
+ * - if the result starts with a digit, prefix `_`
+ * - empty result falls back to `app`
+ */
+export declare function normalizeRustCrateName(raw: string): string;
+/** Build the Cargo.toml body. */
+export declare function buildCargoToml(crateName: string): string;
+/** Build src/main.rs body — minimal Hello world binary. */
+export declare function buildMainRs(): string;
+/** Build src/lib.rs body — public fn + inline tests module. */
+export declare function buildLibRs(): string;
+/** Build tests/integration_test.rs body — smoke test. */
+export declare function buildIntegrationTestRs(): string;
+/**
+ * Augment `.gitignore` with Rust-standard ignores. Idempotent.
+ *
+ * `target/` is always added. `Cargo.lock` is added ONLY when
+ * `includeCargoLock` is true (library-only crates — lockfiles aren't
+ * committed for libraries per Cargo docs). Binary crates commit
+ * Cargo.lock so we leave it out of .gitignore.
+ */
+export declare function augmentGitignore(existing: string | null, includeCargoLock: boolean): string;
+/**
+ * Classify the crate kind based on spec `## Files` paths. See the
+ * file header comment for the fork rules.
+ */
+export type CrateKind = 'binary' | 'library' | 'mixed';
+export declare function classifyCrateKind(paths: string[]): CrateKind;
+export declare function scaffoldRust(ctx: ScaffoldRunContext): Promise<ScaffoldResult>;
+//# sourceMappingURL=rust.d.ts.map

package/dist/src/cli/scaffold/rust.js

@@ -0,0 +1,281 @@
+// v7.7.0 — Rust scaffolder.
+//
+// Mirrors src/cli/scaffold/go.ts (v7.6.0) shape:
+//   - single `scaffoldRust()` exported entrypoint
+//   - pure-function helpers (name normalization, builders) for unit tests
+//   - never overwrites existing files (matches `· exists` log pattern)
+//   - tracks filesCreated / dirsCreated / filesSkippedExisting for return
+//
+// Rust adds a lib-vs-bin fork the Go scaffolder doesn't need:
+//
+//   - spec lists ONLY `src/lib.rs` (no main.rs)         → library crate
+//       Cargo.toml + src/lib.rs (public fn + #[cfg(test)] mod tests)
+//       .gitignore augmentation INCLUDES `Cargo.lock` (lockfiles are
+//       not committed for libraries — see Cargo docs).
+//
+//   - spec lists `src/main.rs` (with or without lib.rs) → binary crate
+//       Cargo.toml + src/main.rs (println!) + tests/integration_test.rs
+//       .gitignore does NOT include Cargo.lock (binaries commit it).
+//
+//   - spec lists BOTH src/main.rs AND src/lib.rs        → mixed mode
+//       Cargo.toml + main.rs + lib.rs + tests/integration_test.rs
+//       .gitignore does NOT include Cargo.lock (binary target wins).
+//
+//   - spec lists NEITHER (or no spec hint)              → default to bin
+//       Same as the `src/main.rs`-listed case. Matches `cargo init`
+//       default — `cargo init` produces a binary unless `--lib` is
+//       passed.
+//
+// Name normalization: Cargo crate identifiers are `[a-z0-9_]` only, must
+// not start with a digit. Lowercase basename(cwd), replace any non-allowed
+// char with `_`, collapse runs of `_`, prefix `_` if the result starts
+// with a digit.
+import * as fs from 'node:fs';
+import * as fsAsync from 'node:fs/promises';
+import * as path from 'node:path';
+const PASS = '\x1b[32m✓\x1b[0m';
+const SKIP = '\x1b[2m·\x1b[0m';
+const DIM = (t) => `\x1b[2m${t}\x1b[0m`;
+/**
+ * Normalize a basename into a valid Cargo crate name.
+ *
+ * Cargo identifiers: `[a-z0-9_]` only, must not start with a digit.
+ *
+ * - lowercased
+ * - any char outside `[a-z0-9_]` collapses to `_`
+ * - repeated `_` runs collapse to a single `_`
+ * - if the result starts with a digit, prefix `_`
+ * - empty result falls back to `app`
+ */
+export function normalizeRustCrateName(raw) {
+    const lower = raw.toLowerCase();
+    // Replace any non-[a-z0-9_] character with `_`.
+    const sanitized = lower.replace(/[^a-z0-9_]+/g, '_');
+    // Collapse repeated `_` runs.
+    const collapsed = sanitized.replace(/_+/g, '_');
+    if (collapsed.length === 0)
+        return 'app';
+    // Strip leading/trailing underscores that came from leading/trailing
+    // separators, BUT preserve a leading `_` we add for digit-start cases.
+    const trimmed = collapsed.replace(/^_+|_+$/g, '');
+    const base = trimmed.length > 0 ? trimmed : 'app';
+    // Cargo crate names cannot start with a digit.
+    return /^[0-9]/.test(base) ? `_${base}` : base;
+}
+/** Build the Cargo.toml body. */
+export function buildCargoToml(crateName) {
+    return `[package]
+name = "${crateName}"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+`;
+}
+/** Build src/main.rs body — minimal Hello world binary. */
+export function buildMainRs() {
+    return `fn main() {
+    println!("Hello from {}", env!("CARGO_PKG_NAME"));
+}
+`;
+}
+/** Build src/lib.rs body — public fn + inline tests module. */
+export function buildLibRs() {
+    return `//! Library entrypoint — auto-scaffolded by claude-autopilot.
+
+pub fn hello() -> &'static str {
+    "hello"
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        assert_eq!(hello(), "hello");
+    }
+}
+`;
+}
+/** Build tests/integration_test.rs body — smoke test. */
+export function buildIntegrationTestRs() {
+    return `#[test]
+fn smoke() {
+    assert_eq!(2 + 2, 4);
+}
+`;
+}
+/**
+ * Augment `.gitignore` with Rust-standard ignores. Idempotent.
+ *
+ * `target/` is always added. `Cargo.lock` is added ONLY when
+ * `includeCargoLock` is true (library-only crates — lockfiles aren't
+ * committed for libraries per Cargo docs). Binary crates commit
+ * Cargo.lock so we leave it out of .gitignore.
+ */
+export function augmentGitignore(existing, includeCargoLock) {
+    const toAddCandidates = includeCargoLock ? ['target/', 'Cargo.lock'] : ['target/'];
+    const lines = existing ? existing.split('\n') : [];
+    const present = new Set(lines.map(l => l.trim()));
+    const toAdd = toAddCandidates.filter(l => !present.has(l));
+    if (toAdd.length === 0)
+        return existing ?? '';
+    const prefix = existing && !existing.endsWith('\n') ? existing + '\n' : (existing ?? '');
+    return prefix + toAdd.join('\n') + '\n';
+}
+export function classifyCrateKind(paths) {
+    const hasMain = paths.includes('src/main.rs');
+    const hasLib = paths.includes('src/lib.rs');
+    if (hasMain && hasLib)
+        return 'mixed';
+    if (hasLib && !hasMain)
+        return 'library';
+    // Default: binary (covers `src/main.rs` listed AND the "neither listed"
+    // case — matches `cargo init` default behavior).
+    return 'binary';
+}
+export async function scaffoldRust(ctx) {
+    const { cwd, parsed, dryRun } = ctx;
+    const crateName = normalizeRustCrateName(path.basename(cwd));
+    const kind = classifyCrateKind(parsed.paths);
+    // Library-only crates omit Cargo.lock from git. Binary + mixed include it.
+    const isLibraryOnly = kind === 'library';
+    const filesCreated = [];
+    const filesSkippedExisting = [];
+    const dirsCreated = [];
+    // Files we generate with content rather than empty placeholders.
+    const MANAGED_FILES = new Set([
+        'Cargo.toml',
+        'src/main.rs',
+        'src/lib.rs',
+        'tests/integration_test.rs',
+        '.gitignore',
+    ]);
+    // 1) Create directories implied by spec paths.
+    const dirs = new Set();
+    for (const p of parsed.paths) {
+        const d = path.dirname(p);
+        if (d && d !== '.')
+            dirs.add(d);
+    }
+    // Ensure we'll have a src/ dir for the targets we write.
+    if (kind !== 'library')
+        dirs.add('src');
+    if (kind === 'library' || kind === 'mixed')
+        dirs.add('src');
+    // tests/ dir for binary + mixed integration tests.
+    if (kind !== 'library')
+        dirs.add('tests');
+    for (const d of dirs) {
+        const abs = path.join(cwd, d);
+        if (fs.existsSync(abs))
+            continue;
+        if (!dryRun)
+            await fsAsync.mkdir(abs, { recursive: true });
+        dirsCreated.push(d);
+        console.log(`  ${PASS}  mkdir   ${DIM(d + '/')}`);
+    }
+    // 2) Empty-placeholder pass for spec paths we don't manage.
+    for (const p of parsed.paths) {
+        if (MANAGED_FILES.has(p))
+            continue;
+        const abs = path.join(cwd, p);
+        if (fs.existsSync(abs)) {
+            filesSkippedExisting.push(p);
+            console.log(`  ${SKIP}  exists  ${DIM(p)}`);
+            continue;
+        }
+        if (!dryRun) {
+            await fsAsync.mkdir(path.dirname(abs), { recursive: true });
+            await fsAsync.writeFile(abs, '', 'utf8');
+        }
+        filesCreated.push(p);
+        console.log(`  ${PASS}  touch   ${DIM(p)}`);
+    }
+    // 3) Cargo.toml — never overwrite.
+    const cargoAbs = path.join(cwd, 'Cargo.toml');
+    if (fs.existsSync(cargoAbs)) {
+        filesSkippedExisting.push('Cargo.toml');
+        console.log(`  ${SKIP}  exists  ${DIM('Cargo.toml (preserved)')}`);
+    }
+    else {
+        if (!dryRun)
+            await fsAsync.writeFile(cargoAbs, buildCargoToml(crateName), 'utf8');
+        filesCreated.push('Cargo.toml');
+        console.log(`  ${PASS}  write   ${DIM(`Cargo.toml (name = "${crateName}", edition 2021)`)}`);
+    }
+    // 4) src/main.rs — binary + mixed modes only.
+    if (kind === 'binary' || kind === 'mixed') {
+        const mainAbs = path.join(cwd, 'src', 'main.rs');
+        if (fs.existsSync(mainAbs)) {
+            filesSkippedExisting.push('src/main.rs');
+            console.log(`  ${SKIP}  exists  ${DIM('src/main.rs (preserved)')}`);
+        }
+        else {
+            if (!dryRun)
+                await fsAsync.writeFile(mainAbs, buildMainRs(), 'utf8');
+            filesCreated.push('src/main.rs');
+            console.log(`  ${PASS}  write   ${DIM('src/main.rs (println! Hello)')}`);
+        }
+    }
+    // 5) src/lib.rs — library + mixed modes only.
+    if (kind === 'library' || kind === 'mixed') {
+        const libAbs = path.join(cwd, 'src', 'lib.rs');
+        if (fs.existsSync(libAbs)) {
+            filesSkippedExisting.push('src/lib.rs');
+            console.log(`  ${SKIP}  exists  ${DIM('src/lib.rs (preserved)')}`);
+        }
+        else {
+            if (!dryRun)
+                await fsAsync.writeFile(libAbs, buildLibRs(), 'utf8');
+            filesCreated.push('src/lib.rs');
+            console.log(`  ${PASS}  write   ${DIM('src/lib.rs (pub fn + #[cfg(test)] mod tests)')}`);
+        }
+    }
+    // 6) tests/integration_test.rs — binary + mixed modes only.
+    if (kind === 'binary' || kind === 'mixed') {
+        const testAbs = path.join(cwd, 'tests', 'integration_test.rs');
+        if (fs.existsSync(testAbs)) {
+            filesSkippedExisting.push('tests/integration_test.rs');
+            console.log(`  ${SKIP}  exists  ${DIM('tests/integration_test.rs (preserved)')}`);
+        }
+        else {
+            if (!dryRun)
+                await fsAsync.writeFile(testAbs, buildIntegrationTestRs(), 'utf8');
+            filesCreated.push('tests/integration_test.rs');
+            console.log(`  ${PASS}  write   ${DIM('tests/integration_test.rs (smoke test)')}`);
+        }
+    }
+    // 7) .gitignore — idempotent augmentation. Cargo.lock conditional on
+    //    library-only crates per Cargo's documented convention.
+    const giAbs = path.join(cwd, '.gitignore');
+    const existing = fs.existsSync(giAbs) ? await fsAsync.readFile(giAbs, 'utf8') : null;
+    const augmented = augmentGitignore(existing, isLibraryOnly);
+    const lockNote = isLibraryOnly ? 'target/, Cargo.lock' : 'target/';
+    if (existing === null) {
+        if (!dryRun)
+            await fsAsync.writeFile(giAbs, augmented, 'utf8');
+        filesCreated.push('.gitignore');
+        console.log(`  ${PASS}  write   ${DIM(`.gitignore (${lockNote})`)}`);
+    }
+    else if (augmented !== existing) {
+        if (!dryRun)
+            await fsAsync.writeFile(giAbs, augmented, 'utf8');
+        filesCreated.push('.gitignore');
+        console.log(`  ${PASS}  augment ${DIM(`.gitignore (added Rust ignores: ${lockNote})`)}`);
+    }
+    else {
+        filesSkippedExisting.push('.gitignore');
+        console.log(`  ${SKIP}  exists  ${DIM('.gitignore (Rust entries already present)')}`);
+    }
+    return {
+        filesCreated,
+        dirsCreated,
+        filesSkippedExisting,
+        // Node-shape fields — Rust scaffolder doesn't touch package.json/tsconfig.
+        packageJsonAction: 'skipped-exists',
+        tsconfigAction: 'skipped-no-ts',
+    };
+}
+//# sourceMappingURL=rust.js.map

package/dist/src/cli/scaffold/types.d.ts

@@ -1,11 +1,14 @@
-/** Supported `--stack` values. v7.6 adds 'go'; v7.7+ will add 'rust'. */
-export type Stack = 'node' | 'python' | 'fastapi' | 'go';
+/** Supported `--stack` values. v7.6 adds 'go'; v7.7 adds 'rust'. */
+export type Stack = 'node' | 'python' | 'fastapi' | 'go' | 'rust';
 /**
  * Stacks we can DETECT but cannot scaffold yet. Detection still warns +
- * exits 3 so the operator gets a clear "v7.7" diagnostic instead of a
+ * exits 3 so the operator gets a clear "vX.Y" diagnostic instead of a
  * silent fallback to Node, which would generate a wrong-language skeleton.
+ *
+ * v7.7 promoted Rust from this list. Ruby remains the lone unsupported
+ * stack (would detect via `Gemfile`).
  */
-export type UnsupportedStack = 'rust' | 'ruby';
+export type UnsupportedStack = 'ruby';
 export interface ParsedFiles {
     /** Raw paths extracted from the `## Files` section bullets. */
     paths: string[];

package/dist/src/cli/scaffold.d.ts

@@ -2,7 +2,7 @@ import { buildStarterPackageJson } from './scaffold/node.ts';
 import type { ParsedFiles, ScaffoldOptions, ScaffoldResult, Stack, UnsupportedStack } from './scaffold/types.ts';
 export { buildStarterPackageJson };
 export type { ScaffoldOptions, ScaffoldResult, ParsedFiles, Stack };
-/** Valid `--stack` argument values. v7.6 adds 'go'; v7.7+ will add 'rust'. */
+/** Valid `--stack` argument values. v7.6 adds 'go'; v7.7 adds 'rust'. */
 export declare const SUPPORTED_STACKS: readonly Stack[];
 /** Stacks we DETECT-but-don't-support yet. Mapped to spec exit-3 messages. */
 export declare const UNSUPPORTED_STACK_FILES: Record<UnsupportedStack, string>;

package/dist/src/cli/scaffold.js

@@ -8,6 +8,8 @@
 //            `parseSpecFiles`, `buildStarterPackageJson`, plus the
 //            `ScaffoldOptions` / `ScaffoldResult` types from here so library
 //            consumers don't break.
+//   v7.6.0 — Go promoted from unsupported to supported.
+//   v7.7.0 — Rust promoted from unsupported to supported (lib/bin fork).
 //
 // Stack detection lives in `detectStack()`. Per the spec ("Stack detection"
 // section), precedence is:
@@ -15,11 +17,13 @@
 //   2. FastAPI (path + 'fastapi' mention) — checked BEFORE generic Python so
 //      a FastAPI spec listing pyproject.toml isn't mis-classified
 //   3. Python (pyproject.toml or requirements.txt)
-//   4. Node (package.json)
-//   5. Detected-but-unsupported (go.mod / Cargo.toml / Gemfile) -> exit 3
-//   6. Fallback: Node ESM (preserves v7.2.0 default for ambiguous specs)
+//   4. Go (go.mod or main.go)
+//   5. Rust (Cargo.toml or src/main.rs or src/lib.rs)
+//   6. Node (package.json)
+//   7. Detected-but-unsupported (Gemfile) -> exit 3
+//   8. Fallback: Node ESM (preserves v7.2.0 default for ambiguous specs)
 //
-// Polyglot guard: package.json AND pyproject.toml together without --stack
+// Polyglot guard: more than one supported-stack signal listed without --stack
 // -> exit 3 with "polyglot spec — pass --stack to disambiguate".
 //
 // Exit codes:
@@ -27,24 +31,24 @@
 //   1 — spec file missing
 //   2 — spec missing `## Files` section
 //   3 (NEW v7.4.0) — `--stack` value not recognized, detected-but-unsupported
-//                    stack (Go/Rust/Ruby), or polyglot spec without --stack
+//                    stack (Ruby), or polyglot spec without --stack
 import * as fs from 'node:fs';
 import * as fsAsync from 'node:fs/promises';
 import * as path from 'node:path';
 import { scaffoldNode, buildStarterPackageJson } from "./scaffold/node.js";
 import { scaffoldPython } from "./scaffold/python.js";
 import { scaffoldGo } from "./scaffold/go.js";
+import { scaffoldRust } from "./scaffold/rust.js";
 const BOLD = (t) => `\x1b[1m${t}\x1b[0m`;
 const DIM = (t) => `\x1b[2m${t}\x1b[0m`;
 // Re-export types + the legacy buildStarterPackageJson so `src/index.ts` and
 // the existing tests/scaffold.test.ts (which imports from this module) keep
 // compiling without changes.
 export { buildStarterPackageJson };
-/** Valid `--stack` argument values. v7.6 adds 'go'; v7.7+ will add 'rust'. */
-export const SUPPORTED_STACKS = ['node', 'python', 'fastapi', 'go'];
+/** Valid `--stack` argument values. v7.6 adds 'go'; v7.7 adds 'rust'. */
+export const SUPPORTED_STACKS = ['node', 'python', 'fastapi', 'go', 'rust'];
 /** Stacks we DETECT-but-don't-support yet. Mapped to spec exit-3 messages. */
 export const UNSUPPORTED_STACK_FILES = {
-    rust: 'Cargo.toml',
     ruby: 'Gemfile',
 };
 /**
@@ -219,11 +223,16 @@ export function detectStack(parsed, explicit) {
     const hasGoMod = has('go.mod');
     const hasMainGo = paths.some(p => p === 'main.go' || /^cmd\/[^/]+\/main\.go$/.test(p));
     const hasGoMarker = hasGoMod || hasMainGo;
+    // v7.7 — Rust signal: `Cargo.toml` OR `src/main.rs` OR `src/lib.rs`.
+    const hasCargoToml = has('Cargo.toml');
+    const hasMainRs = has('src/main.rs');
+    const hasLibRs = has('src/lib.rs');
+    const hasRustMarker = hasCargoToml || hasMainRs || hasLibRs;
     // v7.6 — Polyglot detection scans ALL supported stack signals at once.
     // We collect each present stack and exit 3 if more than one supported
     // stack is detected (e.g. Node + Go, Python + Go, Node + Python + Go).
     // FastAPI is collapsed into Python for the polyglot count (they share
-    // pyproject.toml — not a real conflict).
+    // pyproject.toml — not a real conflict). v7.7 adds Rust to the count.
     const supportedSignals = [];
     if (hasNodeMarker)
         supportedSignals.push('node');
@@ -231,6 +240,8 @@ export function detectStack(parsed, explicit) {
         supportedSignals.push('python');
     if (hasGoMarker)
         supportedSignals.push('go');
+    if (hasRustMarker)
+        supportedSignals.push('rust');
     if (supportedSignals.length > 1) {
         return {
             kind: 'polyglot',
@@ -253,10 +264,13 @@ export function detectStack(parsed, explicit) {
     // Step 4: Go (v7.6).
     if (hasGoMarker)
         return { kind: 'resolved', stack: 'go' };
-    // Step 5: Node.
+    // Step 5: Rust (v7.7).
+    if (hasRustMarker)
+        return { kind: 'resolved', stack: 'rust' };
+    // Step 6: Node.
     if (hasNodeMarker)
         return { kind: 'resolved', stack: 'node' };
-    // Step 6: detected-but-unsupported (codex W2). Rust + Ruby still here.
+    // Step 7: detected-but-unsupported (codex W2). Ruby remains; Rust + Go promoted.
     for (const [stack, file] of Object.entries(UNSUPPORTED_STACK_FILES)) {
         if (has(file)) {
             return {
@@ -281,16 +295,17 @@ export function printStackList() {
     console.log('  python   Python 3.11+ (pyproject.toml + hatchling + pytest)');
     console.log('  fastapi  Python + FastAPI (auto-includes fastapi + uvicorn[standard])');
     console.log('  go       Go 1.22 (go.mod + main.go + main_test.go)');
+    console.log('  rust     Rust 2021 (Cargo.toml + src/{main,lib}.rs + tests/integration_test.rs)');
     console.log('');
     console.log(BOLD('Auto-detected from `## Files`:'));
     console.log('  node     when `package.json` is listed');
     console.log('  python   when `pyproject.toml` or `requirements.txt` is listed');
     console.log('  fastapi  when `main.py` is listed AND a bullet mentions `fastapi`');
     console.log('  go       when `go.mod` or `main.go` is listed');
+    console.log('  rust     when `Cargo.toml`, `src/main.rs`, or `src/lib.rs` is listed');
     console.log('');
     console.log(BOLD('Recognized-but-unsupported (exit 3):'));
-    console.log('  rust     v7.7  (would detect via Cargo.toml)');
-    console.log('  ruby     v7.7+ (would detect via Gemfile)');
+    console.log('  ruby     v7.8+ (would detect via Gemfile)');
     console.log('');
 }
 export async function runScaffold(opts) {
@@ -326,14 +341,15 @@ export async function runScaffold(opts) {
     console.log(`\n${BOLD('[scaffold]')} ${DIM(specAbs)} ${DIM(`(stack: ${stack})`)}\n`);
     // codex W5 — when an explicit --stack is passed against a polyglot spec,
     // strip the OTHER stack's marker files so the chosen scaffolder doesn't
-    // touch them as empty placeholders. v7.6 extends this to Go.
+    // touch them as empty placeholders. v7.6 extends this to Go; v7.7 to Rust.
     let ignoredOtherStackFiles;
     let parsedForStack = parsed;
     const NODE_FILES = new Set(['package.json', 'tsconfig.json']);
     const PYTHON_FILES = new Set(['pyproject.toml', 'requirements.txt']);
     const GO_FILES = new Set(['go.mod']);
+    const RUST_FILES = new Set(['Cargo.toml']);
     if (opts.stack && (stack === 'python' || stack === 'fastapi')) {
-        const toIgnore = new Set([...NODE_FILES, ...GO_FILES]);
+        const toIgnore = new Set([...NODE_FILES, ...GO_FILES, ...RUST_FILES]);
         const ignored = parsed.paths.filter(p => toIgnore.has(p));
         if (ignored.length > 0) {
             ignoredOtherStackFiles = ignored;
@@ -345,7 +361,7 @@ export async function runScaffold(opts) {
         }
     }
     else if (opts.stack === 'node') {
-        const toIgnore = new Set([...PYTHON_FILES, ...GO_FILES]);
+        const toIgnore = new Set([...PYTHON_FILES, ...GO_FILES, ...RUST_FILES]);
         const ignored = parsed.paths.filter(p => toIgnore.has(p));
         if (ignored.length > 0) {
             ignoredOtherStackFiles = ignored;
@@ -357,7 +373,7 @@ export async function runScaffold(opts) {
         }
     }
     else if (opts.stack === 'go') {
-        const toIgnore = new Set([...NODE_FILES, ...PYTHON_FILES]);
+        const toIgnore = new Set([...NODE_FILES, ...PYTHON_FILES, ...RUST_FILES]);
         const ignored = parsed.paths.filter(p => toIgnore.has(p));
         if (ignored.length > 0) {
             ignoredOtherStackFiles = ignored;
@@ -368,6 +384,18 @@ export async function runScaffold(opts) {
             };
         }
     }
+    else if (opts.stack === 'rust') {
+        const toIgnore = new Set([...NODE_FILES, ...PYTHON_FILES, ...GO_FILES]);
+        const ignored = parsed.paths.filter(p => toIgnore.has(p));
+        if (ignored.length > 0) {
+            ignoredOtherStackFiles = ignored;
+            console.log(`  ${DIM(`! ignoring non-Rust files (--stack rust): ${ignored.join(', ')}`)}`);
+            parsedForStack = {
+                ...parsed,
+                paths: parsed.paths.filter(p => !toIgnore.has(p)),
+            };
+        }
+    }
     const ctx = { cwd, parsed: parsedForStack, dryRun: !!opts.dryRun };
     let result;
     if (stack === 'python') {
@@ -379,6 +407,9 @@ export async function runScaffold(opts) {
     else if (stack === 'go') {
         result = await scaffoldGo(ctx);
     }
+    else if (stack === 'rust') {
+        result = await scaffoldRust(ctx);
+    }
     else {
         result = await scaffoldNode(ctx);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delegance/claude-autopilot",
-  "version": "7.6.0",
+  "version": "7.7.0",
   "type": "module",
   "publishConfig": {
     "tag": "next"