@anhvupt/tito 0.1.3 → 0.3.0

package/dist/core/retro.js

@@ -0,0 +1,442 @@
+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) {
+    const lines = [
+        `${report.week} (${report.timezone}, ${report.source})`,
+        report.summary,
+        "reviewFixes: unavailable",
+        "docsBlank: unavailable",
+        "mergeDuration: unavailable",
+    ];
+    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. When a decision depends on an external framework or tool, report the officially maintained resource for the project's version with its maintainer, last update, and a verdict (trusted, use with care, or rejected).",
     }),
     "product-analyst": manifest("product-analyst", {
         tier: "Standard",
@@ -71,7 +71,7 @@ export const SPECIALISTS = Object.freeze({
         triggers: ["clarify requirements", "define acceptance"],
         knowledge: [knowledge("product-analysis", "task")],
         modes: [specialistMode("analyze", "read-only", phase.planning)],
-        stopCondition: "Return one slice and its acceptance criteria.",
+        stopCondition: "Return the Domain section (a business impact line, terms, rules, invariants, and users), one slice, and its acceptance criteria. Offer at most one optional business suggestion.",
     }),
     architect: manifest("architect", {
         tier: "Reasoning",
@@ -79,13 +79,16 @@ export const SPECIALISTS = Object.freeze({
         triggers: ["choose architecture", "resolve a technical trade-off"],
         knowledge: [knowledge("architecture-decisions", "task")],
         modes: [specialistMode("plan", "read-only", phase.planning)],
-        stopCondition: "Return the decided approach and guidance code.",
+        stopCondition: "For each technical decision, return the options with pros and cons and the pick for this project's risk profile. Ask Tito when the project's purpose is unclear. Name any official source with its verdict. Return the decided approach and guidance code.",
     }),
     "backend-engineer": manifest("backend-engineer", {
         tier: "Standard",
         role: "Backend implementer",
         triggers: ["backend implementation", "API or data change"],
-        knowledge: [knowledge("backend-implementation", "task")],
+        knowledge: [
+            knowledge("backend-implementation", "task"),
+            knowledge("official-stack-sources", "stack"),
+        ],
         modes: [specialistMode("implement", "write-files", phase.implementation)],
         stopCondition: "Stop after the approved backend slice is verified.",
     }),
@@ -95,7 +98,7 @@ export const SPECIALISTS = Object.freeze({
         triggers: ["frontend design", "frontend implementation"],
         knowledge: [
             knowledge("frontend-ux", "always"),
-            knowledge("angular", "stack"),
+            knowledge("official-stack-sources", "stack"),
         ],
         modes: [
             specialistMode("design", "read-only", phase.planning, ["preview"]),
@@ -107,7 +110,10 @@ export const SPECIALISTS = Object.freeze({
         tier: "Standard",
         role: "Infrastructure implementer",
         triggers: ["infrastructure plan", "deployment change"],
-        knowledge: [knowledge("devops-safety", "always")],
+        knowledge: [
+            knowledge("devops-safety", "always"),
+            knowledge("official-stack-sources", "stack"),
+        ],
         modes: [
             specialistMode("plan", "read-only", phase.planning),
             specialistMode("implement", "write-infrastructure", phase.implementation, [
@@ -133,7 +139,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",
@@ -144,20 +150,20 @@ export const SPECIALISTS = Object.freeze({
         stopCondition: "Return security findings without editing the slice.",
     }),
     "tech-docs-writer": manifest("tech-docs-writer", {
-        tier: "Standard",
+        tier: "Scout",
         role: "Technical documentation writer",
         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",
+        tier: "Scout",
         role: "User documentation writer",
         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 +182,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 +217,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/terminal.js

@@ -0,0 +1,9 @@
+const RED = "\u001b[31m";
+const RESET = "\u001b[0m";
+export function formatInitError(message, options) {
+    const line = message.endsWith("\n") ? message : `${message}\n`;
+    if (options.tty && options.noColor !== true) {
+        return `${RED}${line}${RESET}`;
+    }
+    return line;
+}

package/dist/core/upgrade.js

@@ -1,7 +1,9 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { compiledCursorAgents } from "./agents.js";
-import { shippedSkills } from "./init.js";
+import { parseConfig } from "./config.js";
+import { PULL_REQUEST_TEMPLATE_PATH, pullRequestTemplate } from "./git-flow.js";
+import { shippedSkills, titoYamlBody } from "./init.js";
 import { TITO_BOOTSTRAP_END, TITO_BOOTSTRAP_START, titoBootstrapBlock, } from "./plan.js";
 function readIfFile(root, path) {
     try {
@@ -52,7 +54,11 @@ export function planUpgrade(root, ownedFiles) {
     return files;
 }
 export function titoOwnedFiles() {
-    return [...compiledCursorAgents(), ...shippedSkills()];
+    return [
+        ...compiledCursorAgents(),
+        ...shippedSkills(),
+        { path: PULL_REQUEST_TEMPLATE_PATH, body: pullRequestTemplate() },
+    ];
 }
 export function formatUpgrade(root, files) {
     const lines = [`root: ${root}`, "consumer rules: untouched"];
@@ -61,6 +67,63 @@ export function formatUpgrade(root, files) {
     }
     return `${lines.join("\n")}\n`;
 }
+export function missingSettings(config) {
+    const missing = [];
+    if (config.git?.defaultBase === undefined)
+        missing.push("defaultBase");
+    if (config.product?.screenLanguage === undefined)
+        missing.push("screenLanguage");
+    if (config.product?.tenancy === undefined)
+        missing.push("tenancy");
+    if (config.product?.surfaces === undefined)
+        missing.push("surfaces");
+    if (config.git?.autoPullRequest === undefined)
+        missing.push("autoPullRequest");
+    return missing;
+}
+export function mergeSettings(yamlText, answers) {
+    const config = parseConfig(yamlText);
+    const settings = {};
+    let changed = false;
+    const existingBase = config.git?.defaultBase;
+    if (existingBase !== undefined)
+        settings.defaultBase = existingBase;
+    else if (answers.defaultBase !== undefined) {
+        settings.defaultBase = answers.defaultBase;
+        changed = true;
+    }
+    const existingAuto = config.git?.autoPullRequest;
+    if (existingAuto !== undefined)
+        settings.autoPullRequest = existingAuto;
+    else if (answers.autoPullRequest !== undefined) {
+        settings.autoPullRequest = answers.autoPullRequest;
+        changed = true;
+    }
+    const existingLanguage = config.product?.screenLanguage;
+    if (existingLanguage !== undefined)
+        settings.screenLanguage = existingLanguage;
+    else if (answers.screenLanguage !== undefined) {
+        settings.screenLanguage = answers.screenLanguage;
+        changed = true;
+    }
+    const existingTenancy = config.product?.tenancy;
+    if (existingTenancy !== undefined)
+        settings.tenancy = existingTenancy;
+    else if (answers.tenancy !== undefined) {
+        settings.tenancy = answers.tenancy;
+        changed = true;
+    }
+    const existingSurfaces = config.product?.surfaces;
+    if (existingSurfaces !== undefined)
+        settings.surfaces = existingSurfaces;
+    else if (answers.surfaces !== undefined && answers.surfaces.length > 0) {
+        settings.surfaces = answers.surfaces;
+        changed = true;
+    }
+    if (!changed)
+        return yamlText;
+    return titoYamlBody(config.profile, settings);
+}
 export function applyUpgrade(root, files) {
     for (const file of files) {
         if (file.action === "keep" || file.body === undefined)

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 = [];