@tiphys/kernel 0.0.0 → 0.2.0

package/dist/src/cli.d.ts

@@ -0,0 +1,9 @@
+/** Exit code for usage errors, per BSD sysexits EX_USAGE. */
+export declare const EX_USAGE = 64;
+export declare function usageLine(): string;
+/**
+ * Dispatch argv (already stripped of the node and script entries) to a
+ * subcommand handler. A missing or unknown subcommand prints the usage
+ * line to stderr and returns EX_USAGE.
+ */
+export declare function run(argv: string[]): Promise<number>;

package/dist/src/cli.js

@@ -0,0 +1,68 @@
+import { cmdBrief } from "./commands/brief.js";
+import { cmdChecklist } from "./commands/checklist.js";
+import { cmdCutover } from "./commands/cutover.js";
+import { cmdDoctor } from "./commands/doctor.js";
+import { cmdGates } from "./commands/gates.js";
+import { cmdInit } from "./commands/init.js";
+import { cmdLock } from "./commands/lock.js";
+import { cmdMode } from "./commands/mode.js";
+import { cmdNext } from "./commands/next.js";
+import { cmdPlan } from "./commands/plan.js";
+import { cmdPool } from "./commands/pool.js";
+import { cmdResume } from "./commands/resume.js";
+import { cmdSpawn } from "./commands/spawn.js";
+import { cmdStatus } from "./commands/status.js";
+import { cmdSync } from "./commands/sync.js";
+import { cmdTeardown } from "./commands/teardown.js";
+import { cmdTuition } from "./commands/tuition.js";
+import { cmdValidate } from "./commands/validate.js";
+import { cmdWatch } from "./commands/watch.js";
+import { printVersion } from "./version.js";
+/** Exit code for usage errors, per BSD sysexits EX_USAGE. */
+export const EX_USAGE = 64;
+/**
+ * The one dispatch table. Subcommands added by later phases register here.
+ */
+const commands = new Map([
+    ["version", printVersion],
+    ["brief", cmdBrief],
+    ["checklist", cmdChecklist],
+    /* M4-P25. The rollback handlers M4-P26 shipped were reachable only by
+       import until this row existed, so the rollback document printed command
+       lines that did not run. */
+    ["cutover", cmdCutover],
+    ["init", cmdInit],
+    ["doctor", cmdDoctor],
+    ["gates", cmdGates],
+    ["lock", cmdLock],
+    ["mode", cmdMode],
+    ["next", cmdNext],
+    ["plan", cmdPlan],
+    ["pool", cmdPool],
+    ["resume", cmdResume],
+    ["spawn", cmdSpawn],
+    ["status", cmdStatus],
+    ["sync", cmdSync],
+    ["teardown", cmdTeardown],
+    ["tuition", cmdTuition],
+    ["validate", cmdValidate],
+    ["watch", cmdWatch],
+]);
+export function usageLine() {
+    const names = [...commands.keys()].sort().join(" | ");
+    return `usage: tiphys <${names}>`;
+}
+/**
+ * Dispatch argv (already stripped of the node and script entries) to a
+ * subcommand handler. A missing or unknown subcommand prints the usage
+ * line to stderr and returns EX_USAGE.
+ */
+export async function run(argv) {
+    const [subcommand, ...rest] = argv;
+    const handler = subcommand === undefined ? undefined : commands.get(subcommand);
+    if (handler === undefined) {
+        process.stderr.write(`${usageLine()}\n`);
+        return EX_USAGE;
+    }
+    return handler(rest);
+}

package/dist/src/commands/brief.d.ts

@@ -0,0 +1,92 @@
+/**
+ * `tiphys brief compose --role <id> --phase <plan-file> --phase-id <id>
+ * [--out <file>]` (kernel plan M3, M3-P5 step 6).
+ *
+ * Resolves `roles/<id>.md` from the installed kernel, checks every
+ * mandated-reading path, expands the shared clause include, and emits the
+ * composed brief: the frontmatter-driven header (which carries the resolved
+ * mandated-reading list, in order), the brief body, the named phase rendered
+ * from the plan instance, and the fleet warnings file when one is present.
+ *
+ * Exit codes:
+ *   0   the brief composed
+ *   1   a resolution failed, and the reason names what
+ *   64  usage error (BSD sysexits EX_USAGE)
+ *
+ * WHAT THIS COMMAND WRITES IS WHAT `tiphys spawn --brief` CONSUMES.
+ * `src/brief.ts` stays the assembly spawn performs at launch and is not
+ * rewritten here, so no M1 contract changes (M3-P5 step 6, and CR-521's
+ * lesson that patching another phase's module from this one is its own
+ * defect).
+ *
+ * D-M3-27, AND IT IS THE POINT OF THE COMMAND RATHER THAN A GARNISH. This
+ * command's entire job is resolving and reading paths it did not create:
+ * a role file named by an operator flag, a plan file named by another, every
+ * mandated-reading entry a brief declares, an included clause block, an
+ * output file, and the fleet warnings file. Every one of those goes through
+ * `classifyEntry` or `refuseOpenForWrite` in src/task.ts, so a named pipe at
+ * any of them is a reported refusal naming the path and the observed entry
+ * type in bounded time. Nothing here opens a path whose type has not been
+ * established, and this module adds no thirteenth instance to the open class
+ * `delivery/STATE.md` records against src/brief.ts, src/hooks.ts and
+ * src/pool.ts.
+ */
+/** Exit code for usage errors, per BSD sysexits EX_USAGE. */
+export declare const EX_USAGE = 64;
+/**
+ * The fleet's environment-warnings file, the same name src/brief.ts appends
+ * at spawn (`WARNINGS_FILE`). Composition has no fleet argument in the usage
+ * the plan fixes, so it looks for the file in the CURRENT WORKING DIRECTORY,
+ * which is the fleet root when an operator composes inside a fleet. Stated
+ * here rather than left implicit, because "the fleet warnings file" names a
+ * location the command is not given.
+ */
+export declare const WARNINGS_FILE = "warnings.md";
+export interface ComposeOptions {
+    roleId: string;
+    planFile: string;
+    phaseId: string;
+    /** The installed kernel root. Injected so tests can stage one. */
+    root: string;
+    /** Where to look for the fleet warnings file. */
+    workingDirectory: string;
+    /**
+     * Which review contract the clean-room brief is running (M3-P6 criterion 10,
+     * T-007). `undefined` means the caller named none, which DEFAULTS to
+     * `criteria` for the one role that has contracts and is a usage error for
+     * every other role. The default is not a shrug: `criteria` is the contract
+     * R-053 already described and the one every existing dispatch means, so the
+     * three briefs M3-P5 shipped and every caller that predates this flag keep
+     * composing unchanged.
+     */
+    reviewContract?: string;
+}
+export type ComposeResult = {
+    ok: true;
+    text: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Compose one brief. Exported so tests drive every arm without a subprocess
+ * and, more importantly, against a STAGED kernel root: the missing-path arm
+ * (criterion 2) and the named-pipe arm (criterion 6c) both need a role brief
+ * pointing at a path this repository must not ship.
+ */
+export declare function composeBrief(options: ComposeOptions): ComposeResult;
+/**
+ * Validate one role brief's clause round trip. Used by
+ * `tiphys validate --type role-brief` after the frontmatter passes its
+ * schema, and exported here so the two live beside the include that makes
+ * them necessary.
+ */
+export declare function roleBriefBodyDiagnostics(briefPath: string, body: string, clauses: readonly string[]): {
+    ok: true;
+    lines: string[];
+} | {
+    ok: false;
+    reason: string;
+};
+/** `tiphys brief <subcommand>`. */
+export declare function cmdBrief(argv: string[]): number;

package/dist/src/commands/brief.js

@@ -0,0 +1,343 @@
+/**
+ * `tiphys brief compose --role <id> --phase <plan-file> --phase-id <id>
+ * [--out <file>]` (kernel plan M3, M3-P5 step 6).
+ *
+ * Resolves `roles/<id>.md` from the installed kernel, checks every
+ * mandated-reading path, expands the shared clause include, and emits the
+ * composed brief: the frontmatter-driven header (which carries the resolved
+ * mandated-reading list, in order), the brief body, the named phase rendered
+ * from the plan instance, and the fleet warnings file when one is present.
+ *
+ * Exit codes:
+ *   0   the brief composed
+ *   1   a resolution failed, and the reason names what
+ *   64  usage error (BSD sysexits EX_USAGE)
+ *
+ * WHAT THIS COMMAND WRITES IS WHAT `tiphys spawn --brief` CONSUMES.
+ * `src/brief.ts` stays the assembly spawn performs at launch and is not
+ * rewritten here, so no M1 contract changes (M3-P5 step 6, and CR-521's
+ * lesson that patching another phase's module from this one is its own
+ * defect).
+ *
+ * D-M3-27, AND IT IS THE POINT OF THE COMMAND RATHER THAN A GARNISH. This
+ * command's entire job is resolving and reading paths it did not create:
+ * a role file named by an operator flag, a plan file named by another, every
+ * mandated-reading entry a brief declares, an included clause block, an
+ * output file, and the fleet warnings file. Every one of those goes through
+ * `classifyEntry` or `refuseOpenForWrite` in src/task.ts, so a named pipe at
+ * any of them is a reported refusal naming the path and the observed entry
+ * type in bounded time. Nothing here opens a path whose type has not been
+ * established, and this module adds no thirteenth instance to the open class
+ * `delivery/STATE.md` records against src/brief.ts, src/hooks.ts and
+ * src/pool.ts.
+ */
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { REVIEW_CONTRACTS, REVIEW_CONTRACT_ROLE, ROLE_BRIEF_FILES, ROLE_IDS, clauseRoundTripDiagnostics, expandIncludes, kernelRoot, missingRequiredSections, renderPhase, resolveMandatedReading, roleBriefFile, selectReviewContract, splitFrontmatter, } from "../roles.js";
+import { refuseOpenForWrite, readRegularFileIfPresent } from "../task.js";
+import { decodeDocument, formatDiagnostics, readOperatorPath } from "../validate.js";
+/** Exit code for usage errors, per BSD sysexits EX_USAGE. */
+export const EX_USAGE = 64;
+/**
+ * The fleet's environment-warnings file, the same name src/brief.ts appends
+ * at spawn (`WARNINGS_FILE`). Composition has no fleet argument in the usage
+ * the plan fixes, so it looks for the file in the CURRENT WORKING DIRECTORY,
+ * which is the fleet root when an operator composes inside a fleet. Stated
+ * here rather than left implicit, because "the fleet warnings file" names a
+ * location the command is not given.
+ */
+export const WARNINGS_FILE = "warnings.md";
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringList(value) {
+    return Array.isArray(value) ? value.map((entry) => String(entry)) : [];
+}
+/**
+ * Compose one brief. Exported so tests drive every arm without a subprocess
+ * and, more importantly, against a STAGED kernel root: the missing-path arm
+ * (criterion 2) and the named-pipe arm (criterion 6c) both need a role brief
+ * pointing at a path this repository must not ship.
+ */
+export function composeBrief(options) {
+    if (!ROLE_IDS.includes(options.roleId)) {
+        return {
+            ok: false,
+            reason: `unknown role ${options.roleId}; the roles are ${ROLE_IDS.join(", ")}`,
+        };
+    }
+    /* THE BRIEF'S LOCATION IS DECLARED, NOT COMPUTED FROM THE ID. Five of the
+       six roles ship as `roles/<id>.md` and the orchestrator's ships as
+       `AGENTS.md` at the package root, so `join(root, "roles", id + ".md")`
+       was a path that does not exist for one advertised role. A role the
+       vocabulary declares and the package does not place is refused BY NAME
+       here, before anything is read, rather than surfacing as a missing file
+       the operator reads as a broken install (src/roles.ts:54). Includes are
+       still resolved against `roles/`, which is where `$include:` targets such
+       as `_shared-dispatch-contract.md` live for every role. */
+    const relative = roleBriefFile(options.roleId);
+    if (relative === undefined) {
+        return {
+            ok: false,
+            reason: `role ${options.roleId} is declared in the role vocabulary and this ` +
+                `package does not say where its brief ships; the placed roles are ` +
+                `${Object.keys(ROLE_BRIEF_FILES).join(", ")}`,
+        };
+    }
+    const rolePath = join(options.root, relative);
+    const roleRead = readOperatorPath(rolePath);
+    if (!roleRead.ok) {
+        return { ok: false, reason: `role brief ${rolePath}: ${roleRead.reason}` };
+    }
+    const split = splitFrontmatter(roleRead.body, rolePath);
+    if (!split.ok) {
+        return { ok: false, reason: split.reason };
+    }
+    const decoded = decodeDocument(split.frontmatter, `${rolePath} frontmatter`);
+    if (!decoded.ok) {
+        return { ok: false, reason: decoded.reason };
+    }
+    const frontmatter = asRecord(decoded.value);
+    if (frontmatter === undefined) {
+        return {
+            ok: false,
+            reason: `${rolePath} frontmatter is not a mapping, so it carries no role-brief fields`,
+        };
+    }
+    const reading = stringList(frontmatter["mandated-reading"]);
+    const resolution = resolveMandatedReading(reading, options.root);
+    if (!resolution.ok) {
+        return { ok: false, reason: resolution.reason };
+    }
+    /* INCLUDES RESOLVE AGAINST THE BRIEF'S OWN DIRECTORY, not against `roles/`.
+       Every brief under `roles/` writes `$include: _shared-dispatch-contract.md`
+       and AGENTS.md, which is the orchestrator's brief at the package root,
+       writes `$include: roles/_shared-dispatch-contract.md`. Both are correct
+       relative to the document they are in, and a fixed `roles/` base turned the
+       second into `roles/roles/_shared-dispatch-contract.md`. */
+    const expanded = expandIncludes(split.body, dirnameOf(rolePath), rolePath);
+    if (!expanded.ok) {
+        return { ok: false, reason: expanded.reason };
+    }
+    /* R-033a, CRITERION 2. Checked on the INCLUDE-EXPANDED body and only for the
+       implementer, because R-033a is the implementer brief's template and no
+       other role's row enumerates sections. A brief that has lost one is refused
+       HERE rather than emitted with a hole, because the failure mode this guards
+       is a brief that reads complete: five sections and no gate list composes
+       cleanly, dispatches cleanly, and instructs an agent to pass gates it was
+       never shown. */
+    if (options.roleId === "implementer") {
+        const missing = missingRequiredSections(expanded.text);
+        if (missing.length > 0) {
+            return { ok: false, reason: `${rolePath}: ${missing.join("; ")}` };
+        }
+    }
+    /* T-007, CRITERION 10. The composed brief declares ONE contract and carries
+       one contract's clauses. The flag is refused for any other role rather than
+       ignored: silently accepting it would let a dispatch believe it had selected
+       a contract for a role that has none. */
+    let body = expanded.text;
+    let reviewContract;
+    if (options.roleId === REVIEW_CONTRACT_ROLE) {
+        reviewContract = options.reviewContract ?? "criteria";
+        if (!REVIEW_CONTRACTS.includes(reviewContract)) {
+            return {
+                ok: false,
+                reason: `unknown review contract ${reviewContract}; the contracts are ${REVIEW_CONTRACTS.join(", ")}`,
+            };
+        }
+        const selected = selectReviewContract(body, reviewContract);
+        if (!selected.ok) {
+            return { ok: false, reason: selected.reason };
+        }
+        body = selected.text;
+    }
+    else if (options.reviewContract !== undefined) {
+        return {
+            ok: false,
+            reason: `--review-contract applies to ${REVIEW_CONTRACT_ROLE} and ${options.roleId} declares no review contracts`,
+        };
+    }
+    const planRead = readOperatorPath(options.planFile);
+    if (!planRead.ok) {
+        return { ok: false, reason: `plan ${options.planFile}: ${planRead.reason}` };
+    }
+    const planDecoded = decodeDocument(planRead.body, options.planFile);
+    if (!planDecoded.ok) {
+        return { ok: false, reason: planDecoded.reason };
+    }
+    const plan = asRecord(planDecoded.value);
+    const phases = Array.isArray(plan?.["phases"]) ? plan["phases"] : [];
+    const phase = phases
+        .map((candidate) => asRecord(candidate))
+        .find((candidate) => candidate?.["id"] === options.phaseId);
+    if (phase === undefined) {
+        return {
+            ok: false,
+            reason: `${options.planFile} declares no phase with id ${options.phaseId}`,
+        };
+    }
+    const lines = [
+        `# Brief: ${options.roleId}`,
+        "",
+        `role: ${String(frontmatter["role"] ?? options.roleId)}`,
+        `lifetime: ${String(frontmatter["lifetime"] ?? "")}`,
+        `model-tier: ${String(frontmatter["model-tier"] ?? "")}`,
+        ...(reviewContract === undefined ? [] : [`review-contract: ${reviewContract}`]),
+        "",
+        "## Mandated reading, in order",
+        "",
+    ];
+    for (let index = 0; index < resolution.paths.length; index += 1) {
+        lines.push(`${String(index + 1)}. ${resolution.paths[index]}`);
+    }
+    lines.push("");
+    lines.push("## Sees");
+    lines.push("");
+    for (const entry of stringList(frontmatter["sees"])) {
+        lines.push(`- ${entry}`);
+    }
+    lines.push("");
+    lines.push("## Never");
+    lines.push("");
+    for (const entry of stringList(frontmatter["never"])) {
+        lines.push(`- ${entry}`);
+    }
+    lines.push("");
+    lines.push("## Verifiers");
+    lines.push("");
+    for (const entry of stringList(frontmatter["verifiers"])) {
+        lines.push(`- ${entry}`);
+    }
+    lines.push("");
+    lines.push("## Outputs");
+    lines.push("");
+    for (const entry of stringList(frontmatter["outputs"])) {
+        lines.push(`- ${entry}`);
+    }
+    lines.push("");
+    lines.push("# Brief body");
+    lines.push("");
+    lines.push(body.replace(/^\n+/, "").replace(/\n+$/, ""));
+    lines.push("");
+    lines.push(...renderPhase(phase));
+    const warnings = readRegularFileIfPresent(join(options.workingDirectory, WARNINGS_FILE));
+    if (warnings.kind === "refused") {
+        return { ok: false, reason: warnings.reason };
+    }
+    if (warnings.kind === "read") {
+        lines.push("# Environment warnings");
+        lines.push("");
+        lines.push(warnings.body.replace(/\n+$/, ""));
+        lines.push("");
+    }
+    return { ok: true, text: `${lines.join("\n").replace(/\n+$/, "")}\n` };
+}
+function usage() {
+    return ("usage: tiphys brief compose --role <" +
+        ROLE_IDS.join(" | ") +
+        "> --phase <plan-file> --phase-id <id> [--out <file>] " +
+        `[--review-contract <${REVIEW_CONTRACTS.join(" | ")}>]`);
+}
+function parseArgs(argv) {
+    const options = {};
+    const flags = new Map([
+        ["--role", "role"],
+        ["--phase", "phase"],
+        ["--phase-id", "phaseId"],
+        ["--out", "out"],
+        ["--review-contract", "reviewContract"],
+    ]);
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const field = flags.get(argument);
+        if (field === undefined) {
+            return { usageError: `unknown option ${argument}` };
+        }
+        const value = argv[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+            return { usageError: `${argument} requires a value` };
+        }
+        options[field] = value;
+        index += 1;
+    }
+    const optional = new Set(["out", "reviewContract"]);
+    for (const [flag, field] of flags) {
+        if (!optional.has(field) && options[field] === undefined) {
+            return { usageError: `${flag} is required` };
+        }
+    }
+    return { options };
+}
+function cmdCompose(argv) {
+    const parsed = parseArgs(argv);
+    if (parsed.options === undefined) {
+        process.stderr.write(`tiphys brief compose: ${parsed.usageError ?? "usage error"}\n`);
+        process.stderr.write(`${usage()}\n`);
+        return EX_USAGE;
+    }
+    const { role, phase, phaseId, out, reviewContract } = parsed.options;
+    let root;
+    try {
+        root = kernelRoot();
+    }
+    catch (error) {
+        process.stderr.write(`tiphys brief compose: ${error.message}\n`);
+        return 1;
+    }
+    const composed = composeBrief({
+        roleId: role,
+        planFile: phase,
+        phaseId: phaseId,
+        root,
+        workingDirectory: process.cwd(),
+        ...(reviewContract === undefined ? {} : { reviewContract }),
+    });
+    if (!composed.ok) {
+        process.stderr.write(`tiphys brief compose: ${composed.reason}\n`);
+        return 1;
+    }
+    if (out === undefined) {
+        process.stdout.write(composed.text);
+        return 0;
+    }
+    const refusal = refuseOpenForWrite(out);
+    if (refusal !== undefined) {
+        process.stderr.write(`tiphys brief compose: ${refusal}\n`);
+        return 1;
+    }
+    writeFileSync(out, composed.text);
+    return 0;
+}
+/**
+ * Validate one role brief's clause round trip. Used by
+ * `tiphys validate --type role-brief` after the frontmatter passes its
+ * schema, and exported here so the two live beside the include that makes
+ * them necessary.
+ */
+export function roleBriefBodyDiagnostics(briefPath, body, clauses) {
+    const expanded = expandIncludes(body, dirnameOf(briefPath), briefPath);
+    if (!expanded.ok) {
+        return { ok: false, reason: expanded.reason };
+    }
+    return {
+        ok: true,
+        lines: formatDiagnostics(clauseRoundTripDiagnostics(clauses, expanded.text)),
+    };
+}
+function dirnameOf(path) {
+    const index = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+    return index === -1 ? "." : path.slice(0, index);
+}
+/** `tiphys brief <subcommand>`. */
+export function cmdBrief(argv) {
+    const [subcommand, ...rest] = argv;
+    if (subcommand === "compose") {
+        return cmdCompose(rest);
+    }
+    process.stderr.write(`tiphys brief: ${subcommand === undefined ? "a subcommand is required" : `unknown subcommand ${subcommand}`}\n`);
+    process.stderr.write(`${usage()}\n`);
+    return EX_USAGE;
+}

package/dist/src/commands/checklist.d.ts

@@ -0,0 +1,42 @@
+/**
+ * `tiphys checklist resolve --checklist <id> [--extra <file>] [--framing <id>]`
+ * (kernel plan M3, M3-P7 step 5; R-054, T-001).
+ *
+ * PROBE INJECTION AS DATA. The orchestrator writes a per-phase probe file and
+ * this command merges it into the canonical checklist, so a per-phase probe
+ * set is reviewable and reusable instead of living in a dispatch prompt
+ * nobody can diff. The AGENTS.md duty to WRITE them is M3-P9's; this is the
+ * mechanism they plug into.
+ *
+ * IT VALIDATES BEFORE IT SERVES. Both documents go through exactly what
+ * `tiphys validate --type checklist` runs, schema first and derived checks
+ * second, and a document that fails is REFUSED rather than partly printed.
+ * That is the M3-P3 `mode show` fix round applied at the site that would
+ * otherwise repeat it: as first shipped, that command read a document and
+ * printed it, invoking neither the schema nor any registered check, so every
+ * guard its phase built was bypassed on the one path built for humans. A
+ * partial answer from an invalid checklist is worse than an error, because
+ * the reviewer cannot tell.
+ *
+ * THE CONTEXT FOR THE DERIVED CHECKS IS THE PACKAGE ROOT, which is where
+ * `gate-registry.yaml` sits, so `gate-probes-resolve` RUNS here rather than
+ * SKIPPING. A skip fails the run, and a command that always failed would be a
+ * command nobody uses.
+ *
+ * Exit codes:
+ *   0   both documents are valid, the framing resolved, and the list printed
+ *   1   a document could not be read or is invalid, an extra probe collided
+ *       or required no evidence, or the named framing is not declared
+ *   64  usage error (BSD sysexits EX_USAGE)
+ *
+ * A FRAMING ID THAT IS NOT DECLARED IS 1, NOT 64, for the reason
+ * `tiphys mode show` records for an undeclared mode: 64 means the caller used
+ * the command wrongly, 1 means the command worked and the answer is no.
+ * `--framing fix-round` against a checklist that declares only
+ * `criteria-contract` is a well formed question with a negative answer.
+ */
+/** Exit code for usage errors, per BSD sysexits EX_USAGE. */
+export declare const EX_USAGE = 64;
+export declare function cmdChecklist(argv: string[]): number;
+/** The shipped ids, for the usage line and for tests that must not hand-list them. */
+export declare function declaredChecklistIds(): string[];