@anhvupt/tito 0.1.2 → 0.2.0

package/dist/core/retro.js

@@ -0,0 +1,444 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { AdminError, defaultGitRunner, isSecretFilename, loadRepos, } from "./admin.js";
+import { parseConfig } from "./config.js";
+import { readFeedbackOutcome } from "./feedback.js";
+import { RISK_PROFILES } from "./profiles.js";
+export const PREFIX_RULE_MARKER = "A commit subject is `<type>: <sentence>`.";
+const WEEK_ID = /^(\d{4})-W(\d{2})$/;
+const TYPE_PREFIX = /^(feat|fix|hot-fix|chores|refactor|debug): /;
+const MERGE_PULL_REQUEST = /^Merge pull request #\d+/;
+const MERGE_BRANCH = /^Merge branch(?:\s|$)/;
+const REVIEW_PATH = /^\.tito\/feedback\/[a-z0-9]+(?:-[a-z0-9]+)*\/review\.md$/;
+const QUIET_SUMMARY = "No Tito activity this week.";
+export class RetroError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "RetroError";
+        this.code = code;
+    }
+}
+export function machineTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+export function isIanaTimeZone(timeZone) {
+    try {
+        Intl.DateTimeFormat("en-US", { timeZone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function weeksInIsoYear(year) {
+    const januaryFirst = new Date(Date.UTC(year, 0, 1)).getUTCDay();
+    const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    if (januaryFirst === 4 || (leap && januaryFirst === 3))
+        return 53;
+    return 52;
+}
+export function parseWeekId(value) {
+    const match = WEEK_ID.exec(value);
+    if (match === null)
+        return null;
+    const year = Number(match[1]);
+    const week = Number(match[2]);
+    if (!Number.isInteger(year) || !Number.isInteger(week))
+        return null;
+    if (week < 1 || week > weeksInIsoYear(year))
+        return null;
+    return { year, week };
+}
+function formatWeekId(year, week) {
+    return `${year}-W${String(week).padStart(2, "0")}`;
+}
+function partValue(parts, type) {
+    return parts.find((part) => part.type === type)?.value ?? null;
+}
+function civilDate(instant, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).formatToParts(instant);
+    const year = partValue(parts, "year");
+    const month = partValue(parts, "month");
+    const day = partValue(parts, "day");
+    if (year === null || month === null || day === null) {
+        throw new RetroError("invalid-timezone", `Timezone "${timeZone}" is not an IANA name.`);
+    }
+    return { year: Number(year), month: Number(month), day: Number(day) };
+}
+function isoWeekOfCivil(civil) {
+    const date = new Date(Date.UTC(civil.year, civil.month - 1, civil.day));
+    const weekday = date.getUTCDay() || 7;
+    date.setUTCDate(date.getUTCDate() + 4 - weekday);
+    const year = date.getUTCFullYear();
+    const yearStart = new Date(Date.UTC(year, 0, 1));
+    const dayIndex = Math.round((date.getTime() - yearStart.getTime()) / 86400000);
+    const week = Math.ceil((dayIndex + 1) / 7);
+    return { year, week };
+}
+export function isoWeekId(instant, timeZone) {
+    if (!isIanaTimeZone(timeZone)) {
+        throw new RetroError("invalid-timezone", `Timezone "${timeZone}" is not an IANA name.`);
+    }
+    const week = isoWeekOfCivil(civilDate(instant, timeZone));
+    return formatWeekId(week.year, week.week);
+}
+function timeZoneOffsetMs(instant, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    }).formatToParts(instant);
+    const year = partValue(parts, "year");
+    const month = partValue(parts, "month");
+    const day = partValue(parts, "day");
+    const minute = partValue(parts, "minute");
+    const second = partValue(parts, "second");
+    let hour = partValue(parts, "hour");
+    if (year === null || month === null || day === null || hour === null || minute === null || second === null) {
+        throw new RetroError("invalid-timezone", `Timezone "${timeZone}" is not an IANA name.`);
+    }
+    if (hour === "24")
+        hour = "00";
+    const asUtc = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second));
+    return asUtc - instant.getTime();
+}
+function zonedMidnightUtc(civil, timeZone) {
+    const guess = Date.UTC(civil.year, civil.month - 1, civil.day, 0, 0, 0, 0);
+    const first = guess - timeZoneOffsetMs(new Date(guess), timeZone);
+    const second = guess - timeZoneOffsetMs(new Date(first), timeZone);
+    return new Date(second);
+}
+function addDays(civil, days) {
+    const date = new Date(Date.UTC(civil.year, civil.month - 1, civil.day + days));
+    return {
+        year: date.getUTCFullYear(),
+        month: date.getUTCMonth() + 1,
+        day: date.getUTCDate(),
+    };
+}
+function isoWeekMonday(year, week) {
+    const januaryFourth = new Date(Date.UTC(year, 0, 4));
+    const weekday = januaryFourth.getUTCDay() || 7;
+    const monday = new Date(januaryFourth);
+    monday.setUTCDate(januaryFourth.getUTCDate() - (weekday - 1) + (week - 1) * 7);
+    return {
+        year: monday.getUTCFullYear(),
+        month: monday.getUTCMonth() + 1,
+        day: monday.getUTCDate(),
+    };
+}
+export function weekRange(weekId, timeZone) {
+    const parsed = parseWeekId(weekId);
+    if (parsed === null) {
+        throw new RetroError("invalid-week", `Week "${weekId}" is not an ISO week (YYYY-Www).`);
+    }
+    if (!isIanaTimeZone(timeZone)) {
+        throw new RetroError("invalid-timezone", `Timezone "${timeZone}" is not an IANA name.`);
+    }
+    const monday = isoWeekMonday(parsed.year, parsed.week);
+    return {
+        start: zonedMidnightUtc(monday, timeZone),
+        end: zonedMidnightUtc(addDays(monday, 7), timeZone),
+    };
+}
+function isMergeSubject(subject) {
+    return MERGE_PULL_REQUEST.test(subject) || MERGE_BRANCH.test(subject);
+}
+export function countPrefixMisses(commits, ruleLandedAt, range) {
+    if (ruleLandedAt === null)
+        return 0;
+    const landed = Date.parse(ruleLandedAt);
+    if (Number.isNaN(landed))
+        return 0;
+    const start = range.start.getTime();
+    const end = range.end.getTime();
+    let count = 0;
+    for (const commit of commits) {
+        const at = Date.parse(commit.date);
+        if (Number.isNaN(at) || at < start || at >= end || at < landed)
+            continue;
+        if (isMergeSubject(commit.subject) || TYPE_PREFIX.test(commit.subject))
+            continue;
+        count += 1;
+    }
+    return count;
+}
+export function countReviewOutcomes(texts) {
+    const outcomes = {
+        accepted: 0,
+        edited: 0,
+        expanded: 0,
+        unknown: 0,
+    };
+    for (const text of texts) {
+        outcomes[readFeedbackOutcome(text)] += 1;
+    }
+    return outcomes;
+}
+function emptyOutcomes() {
+    return { accepted: 0, edited: 0, expanded: 0, unknown: 0 };
+}
+function authoredFileLimit(profile) {
+    const value = RISK_PROFILES[profile];
+    return "maxAuthoredFiles" in value ? value.maxAuthoredFiles : null;
+}
+function sliceFileLimit(repoPath) {
+    const configPath = join(repoPath, "tito.yaml");
+    if (!existsSync(configPath))
+        return null;
+    try {
+        return authoredFileLimit(parseConfig(readFileSync(configPath, "utf8")).profile);
+    }
+    catch {
+        return null;
+    }
+}
+function countSliceOverLimit(commits, limit) {
+    if (limit === null)
+        return 0;
+    let count = 0;
+    for (const commit of commits) {
+        if (commit.files.length > limit)
+            count += 1;
+    }
+    return count;
+}
+function countMerged(commits) {
+    let count = 0;
+    for (const commit of commits) {
+        if (MERGE_PULL_REQUEST.test(commit.subject))
+            count += 1;
+    }
+    return count;
+}
+function summarize(commitCount, prefixMisses, sliceOverLimit, merged, outcomes) {
+    if (commitCount === 0)
+        return QUIET_SUMMARY;
+    const noun = commitCount === 1 ? "commit" : "commits";
+    return `${commitCount} ${noun}; prefix misses ${prefixMisses}; slice over limit ${sliceOverLimit}; merged ${merged}; outcomes ${outcomes.accepted} accepted, ${outcomes.edited} edited, ${outcomes.expanded} expanded, ${outcomes.unknown} unknown.`;
+}
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function tryGit(git, cwd, args) {
+    try {
+        return git(cwd, args);
+    }
+    catch {
+        return null;
+    }
+}
+function gitInstant(date) {
+    return date.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function parseRetroLog(stdout) {
+    const commits = [];
+    for (const block of stdout.split(/\n(?=◆)/)) {
+        const trimmed = block.trim();
+        if (!trimmed.startsWith("◆"))
+            continue;
+        const lines = trimmed.split("\n");
+        const header = lines[0];
+        if (header === undefined || !header.startsWith("◆"))
+            continue;
+        const parts = header.slice(1).split("\0");
+        const hash = parts[0] ?? "";
+        const subject = parts[1] ?? "";
+        const date = parts[2] ?? "";
+        if (hash.length === 0)
+            continue;
+        const files = [];
+        for (const line of lines.slice(1)) {
+            const file = line.trim();
+            if (file.length === 0 || isSecretFilename(file))
+                continue;
+            files.push(file);
+        }
+        commits.push({ hash, subject, date, files });
+    }
+    return commits;
+}
+function inRange(date, range) {
+    const at = Date.parse(date);
+    return !Number.isNaN(at) && at >= range.start.getTime() && at < range.end.getTime();
+}
+function readWeekCommits(git, repoPath, range) {
+    const since = gitInstant(new Date(range.start.getTime() - 1000));
+    const log = git(repoPath, [
+        "log",
+        `--since=${since}`,
+        `--until=${gitInstant(range.end)}`,
+        "--pretty=format:◆%H%x00%s%x00%cI",
+        "--name-only",
+    ]);
+    return parseRetroLog(log).filter((commit) => inRange(commit.date, range));
+}
+function ruleLandedAt(git, repoPath) {
+    const log = git(repoPath, [
+        "log",
+        "--reverse",
+        "--pretty=format:%H%x00%cI",
+        "--",
+        "AGENTS.md",
+    ]);
+    for (const line of log.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        const [hash, date] = trimmed.split("\0");
+        if (hash === undefined || date === undefined || hash.length === 0 || date.length === 0)
+            continue;
+        const text = tryGit(git, repoPath, ["show", `${hash}:AGENTS.md`]);
+        if (text !== null && text.includes(PREFIX_RULE_MARKER))
+            return date;
+    }
+    return null;
+}
+function reviewTexts(git, repoPath, commits) {
+    const hashesByPath = new Map();
+    for (const commit of commits) {
+        for (const file of commit.files) {
+            if (!REVIEW_PATH.test(file))
+                continue;
+            const hashes = hashesByPath.get(file);
+            if (hashes === undefined)
+                hashesByPath.set(file, [commit.hash]);
+            else
+                hashes.push(commit.hash);
+        }
+    }
+    const texts = [];
+    for (const [file, hashes] of hashesByPath) {
+        for (const hash of hashes) {
+            const text = tryGit(git, repoPath, ["show", `${hash}:${file}`]);
+            if (text === null)
+                continue;
+            texts.push(text);
+            break;
+        }
+    }
+    return texts;
+}
+export function buildRetro(options) {
+    const timezone = options.timezone ?? machineTimeZone();
+    if (!isIanaTimeZone(timezone)) {
+        throw new RetroError("invalid-timezone", `Timezone "${timezone}" is not an IANA name.`);
+    }
+    const week = options.week ?? isoWeekId(options.now ?? new Date(), timezone);
+    if (parseWeekId(week) === null) {
+        throw new RetroError("invalid-week", `Week "${week}" is not an ISO week (YYYY-Www).`);
+    }
+    const range = weekRange(week, timezone);
+    const git = options.git ?? defaultGitRunner;
+    const outcomes = emptyOutcomes();
+    const repos = [];
+    let prefixMisses = 0;
+    let sliceOverLimit = 0;
+    let merged = 0;
+    let commitCount = 0;
+    for (const repo of loadRepos(options.adminRoot)) {
+        if (!isDirectory(repo.path)) {
+            repos.push({ path: repo.path, missing: true });
+            continue;
+        }
+        repos.push({ path: repo.path });
+        const commits = readWeekCommits(git, repo.path, range);
+        commitCount += commits.length;
+        prefixMisses += countPrefixMisses(commits, ruleLandedAt(git, repo.path), range);
+        sliceOverLimit += countSliceOverLimit(commits, sliceFileLimit(repo.path));
+        merged += countMerged(commits);
+        const counted = countReviewOutcomes(reviewTexts(git, repo.path, commits));
+        outcomes.accepted += counted.accepted;
+        outcomes.edited += counted.edited;
+        outcomes.expanded += counted.expanded;
+        outcomes.unknown += counted.unknown;
+    }
+    return {
+        week,
+        timezone,
+        source: "local",
+        summary: summarize(commitCount, prefixMisses, sliceOverLimit, merged, outcomes),
+        alerts: [],
+        outcomes,
+        prefixMisses,
+        sliceOverLimit,
+        merged,
+        reviewFixes: "unavailable",
+        docsBlank: "unavailable",
+        mergeDuration: "unavailable",
+        repos,
+    };
+}
+export function formatRetro(report, options = {}) {
+    const lines = [
+        `${report.week} (${report.timezone}, ${report.source})`,
+        report.summary,
+        "reviewFixes: unavailable",
+        "docsBlank: unavailable",
+        "mergeDuration: unavailable",
+    ];
+    if (options.alerts === true)
+        lines.push("alerts: []");
+    for (const repo of report.repos) {
+        if (repo.missing === true)
+            lines.push(`missing: ${repo.path}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function formatRetroMarkdown(report) {
+    const outcomes = report.outcomes;
+    const lines = [
+        `# ${report.week}`,
+        "",
+        `Timezone: ${report.timezone}. Source: local.`,
+        "",
+        report.summary,
+        "",
+        `Prefix misses: ${report.prefixMisses}. Slice over limit: ${report.sliceOverLimit}. Merged: ${report.merged}.`,
+        `Outcomes: ${outcomes.accepted} accepted, ${outcomes.edited} edited, ${outcomes.expanded} expanded, ${outcomes.unknown} unknown.`,
+        "Review fixes: unavailable. Docs blank: unavailable. Merge duration: unavailable.",
+        "Alerts: none.",
+    ];
+    const missing = report.repos.filter((repo) => repo.missing === true);
+    if (missing.length > 0) {
+        lines.push("", "Missing repos:");
+        for (const repo of missing)
+            lines.push(`- ${repo.path}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function retroJson(report) {
+    return `${JSON.stringify(report, null, 2)}\n`;
+}
+function writeTextAtomic(path, text) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    try {
+        writeFileSync(tmp, text, "utf8");
+        renameSync(tmp, path);
+    }
+    catch (error) {
+        throw new AdminError("filesystem", path, error instanceof Error ? error.message : `Cannot write ${path}.`);
+    }
+}
+export function saveRetro(adminRoot, report) {
+    const dir = join(resolve(adminRoot), "retros");
+    writeTextAtomic(join(dir, `${report.week}.json`), retroJson(report));
+    writeTextAtomic(join(dir, `${report.week}.md`), formatRetroMarkdown(report));
+}

package/dist/core/specialists.js

@@ -63,7 +63,7 @@ export const SPECIALISTS = Object.freeze({
         triggers: ["where code lives", "how behavior works"],
         knowledge: [knowledge("explorer-scout", "always")],
         modes: [specialistMode("scout", "read-only", phase.discovery)],
-        stopCondition: "Return evidence, gaps, and the next specialist.",
+        stopCondition: "When scouting for a plan, report the principles and project conventions relevant to the decisions, and where each convention lives (AGENTS.md, a .cursor/rules file, or an existing pattern). Stay read-only. Return evidence, gaps, and the next specialist to Tito.",
     }),
     "product-analyst": manifest("product-analyst", {
         tier: "Standard",
@@ -133,7 +133,7 @@ export const SPECIALISTS = Object.freeze({
         triggers: ["review correctness", "check edge cases"],
         knowledge: [knowledge("qa-review", "always")],
         modes: [specialistMode("review", "read-only", phase.review)],
-        stopCondition: "Return findings without editing the slice.",
+        stopCondition: "For a plan, return Arrange / Act / Assert test cases with an ID and a layer tag `[unit]`, `[integration]`, or `[e2e]`. When tenancy is multi or more than one surface is declared, draft the applicable kinds: isolation, consistency, propagation, and permissions. Integration is the default. End-to-end only when the plan names a journey. After coding, check each approved test ID as passing or failing, and flag any test that was not in the approved list. Stay read-only. Return findings without editing the slice.",
     }),
     "security-reviewer": manifest("security-reviewer", {
         tier: "Reasoning",
@@ -149,7 +149,7 @@ export const SPECIALISTS = Object.freeze({
         triggers: ["module finished", "update technical documentation"],
         knowledge: [knowledge("tech-docs", "task")],
         modes: [specialistMode("update", "write-files", phase.implementation)],
-        stopCondition: "Stop after the technical docs match the finished module.",
+        stopCondition: "Apply the plan's Docs impact (update named docs, or record a waiver) before a pull request. The module-end pass still covers larger docs. Stop after that docs work matches the plan.",
     }),
     "user-docs-writer": manifest("user-docs-writer", {
         tier: "Standard",
@@ -157,7 +157,7 @@ export const SPECIALISTS = Object.freeze({
         triggers: ["module finished", "update user documentation"],
         knowledge: [knowledge("user-docs", "task")],
         modes: [specialistMode("update", "write-files", phase.implementation)],
-        stopCondition: "Stop after the user docs match the finished module.",
+        stopCondition: "Apply the plan's Docs impact (update named docs, or record a waiver) before a pull request. The module-end pass still covers larger docs. Stop after that docs work matches the plan.",
     }),
 });
 export class DelegationError extends Error {
@@ -176,7 +176,8 @@ function reject(code, message) {
 function isSpecialistId(value) {
     return SPECIALIST_IDS.includes(value);
 }
-export function validateDelegation(activations, phaseName) {
+const DOCUMENTATION_WRITERS = new Set(["tech-docs-writer", "user-docs-writer"]);
+export function validateDelegation(activations, phaseName, maxWriters = 1) {
     const seen = new Set();
     const resolved = [];
     for (const activation of activations) {
@@ -210,11 +211,16 @@ export function validateDelegation(activations, phaseName) {
         });
     }
     const mutators = resolved.filter((item) => item.capability !== "read-only");
-    if (mutators.length > 1) {
-        reject("multiple-mutators", "Only one specialist mode may mutate at a time.");
+    const documentationWriters = mutators.filter((item) => DOCUMENTATION_WRITERS.has(item.specialistId));
+    if (documentationWriters.length > 1) {
+        reject("multiple-mutators", "Documentation writers run one at a time.");
+    }
+    if (mutators.length > maxWriters) {
+        reject("multiple-mutators", `At most ${maxWriters} specialist modes may mutate at a time.`);
     }
     return {
-        mutator: mutators[0] ?? null,
+        mutator: mutators.length === 1 ? (mutators[0] ?? null) : null,
+        mutators,
         advisers: resolved.filter((item) => item.capability === "read-only"),
     };
 }

package/dist/core/upgrade.js

@@ -0,0 +1,77 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { compiledCursorAgents } from "./agents.js";
+import { PULL_REQUEST_TEMPLATE_PATH, pullRequestTemplate } from "./git-flow.js";
+import { shippedSkills } from "./init.js";
+import { TITO_BOOTSTRAP_END, TITO_BOOTSTRAP_START, titoBootstrapBlock, } from "./plan.js";
+function readIfFile(root, path) {
+    try {
+        return readFileSync(join(root, path), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function ownedText(current, next) {
+    if (current === null)
+        return "create";
+    return current === next ? "keep" : "replace";
+}
+export function refreshAgentsBootstrap(current) {
+    const block = titoBootstrapBlock().trimEnd();
+    const start = current.indexOf(TITO_BOOTSTRAP_START);
+    const end = current.indexOf(TITO_BOOTSTRAP_END);
+    if (start >= 0 && end > start) {
+        return `${current.slice(0, start)}${block}${current.slice(end + TITO_BOOTSTRAP_END.length)}`;
+    }
+    const heading = current.indexOf("# Tito bootstrap");
+    if (heading >= 0) {
+        const prefix = current.slice(0, heading).trimEnd();
+        return prefix.length === 0 ? `${block}\n` : `${prefix}\n\n${block}\n`;
+    }
+    const trimmed = current.trimEnd();
+    return `${trimmed}\n\n${block}\n`;
+}
+export function planUpgrade(root, ownedFiles) {
+    const files = ownedFiles.map((file) => {
+        const current = readIfFile(root, file.path);
+        const action = ownedText(current, file.body);
+        return action === "keep"
+            ? { path: file.path, action }
+            : { path: file.path, action, body: file.body };
+    });
+    const agents = readIfFile(root, "AGENTS.md");
+    if (agents === null) {
+        files.push({ path: "AGENTS.md", action: "create", body: titoBootstrapBlock() });
+    }
+    else {
+        const next = refreshAgentsBootstrap(agents);
+        files.push(next === agents
+            ? { path: "AGENTS.md", action: "keep" }
+            : { path: "AGENTS.md", action: "replace", body: next });
+    }
+    return files;
+}
+export function titoOwnedFiles() {
+    return [
+        ...compiledCursorAgents(),
+        ...shippedSkills(),
+        { path: PULL_REQUEST_TEMPLATE_PATH, body: pullRequestTemplate() },
+    ];
+}
+export function formatUpgrade(root, files) {
+    const lines = [`root: ${root}`, "consumer rules: untouched"];
+    for (const file of files) {
+        lines.push(`${file.path}: ${file.action}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function applyUpgrade(root, files) {
+    for (const file of files) {
+        if (file.action === "keep" || file.body === undefined)
+            continue;
+        const absolute = join(root, file.path);
+        mkdirSync(dirname(absolute), { recursive: true });
+        writeFileSync(absolute, file.body, "utf8");
+    }
+}

package/dist/core/work-plan.js

@@ -1,5 +1,5 @@
 import { LIFECYCLE_STATES, } from "./lifecycle.js";
-import { isActiveRiskProfileId, } from "./profiles.js";
+import { RISK_PROFILES, isActiveRiskProfileId, } from "./profiles.js";
 import { SPECIALISTS, } from "./specialists.js";
 export class WorkPlanError extends Error {
     code;
@@ -177,14 +177,15 @@ export function evaluateWorkPlan(plan, progress) {
     }
     const activeWriters = validated.slices.filter((slice) => slice.kind === "implementation" &&
         progress.implementationStates[slice.id] === "IMPLEMENTING");
-    if (activeWriters.length > 1) {
-        reject("multiple-active-writers", "Only one implementation slice may be active.");
+    const maxWriters = RISK_PROFILES[validated.profile].maxWriters;
+    if (activeWriters.length > maxWriters) {
+        reject("multiple-active-writers", `At most ${maxWriters} implementation slices may be active.`);
     }
     const unreviewedSlices = validated.slices.filter((slice) => slice.kind === "implementation" &&
         progress.implementationStates[slice.id] === "READY_FOR_REVIEW");
     if (validated.profile === "client-careful" &&
-        activeWriters.length + unreviewedSlices.length > 1) {
-        reject("invalid-progress", "Client-careful cannot stack unreviewed work.");
+        activeWriters.length + unreviewedSlices.length > maxWriters) {
+        reject("invalid-progress", "Client-careful cannot stack unreviewed work beyond its writer cap.");
     }
     const dependencyReasons = (slice) => {
         const reasons = [];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@anhvupt/tito",
-  "version": "0.1.2",
-  "description": "Local-first AI development harness for solo builders.",
+  "version": "0.2.0",
+  "description": "Chat-first engineering coordinator for solo builders. The plan is the spec: decisions, test cases, and docs.",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {