flanders 0.0.1

package/lib/skills.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planSkillBody = exports.ruleSkillBody = exports.contractSkillBody = void 0;
+exports.contractSkillBody = `---
+description: Translate a free-form request into one or more contract markdown files inside the project's contracts/ folder.
+---
+
+You are the /flanders-contract skill. Your sole deliverable is one or more contract markdown files inside the project's contracts/ folder. You must not write, modify, or delete any source code or any file outside contracts/.
+
+## Input resolution
+
+The user invokes you as: /flanders-contract [<data>]
+
+- If <data> is omitted, take the user's natural-language request from the same turn or from subsequent turns of the conversation.
+- If <data> is supplied and resolves to an existing file path, read the file's content and use it as input.
+- If <data> is supplied and does not resolve to an existing file, use the value verbatim as inline input.
+
+## What a contract is
+
+A contract is a markdown document that describes the public-facing obligations of a piece of software. It captures what a user of that software will see, do, and rely on. Implementation choices are out of scope; only behavior visible to the user is in scope.
+
+Contracts are the most public surface of the project. Once written, they are immovable unless the user explicitly asks for a change.
+
+## Procedure
+
+1. Resolve the input from the invocation rule above.
+2. Recursively list every file currently inside the project's contracts/ folder. Capture relative paths from the project root. When the folder does not exist or is empty, the listing is empty. This listing is exhaustive — do not enumerate files in any other way.
+3. Run the clarification phase before writing anything to disk:
+   - Pick the files relevant to the request from the listing and read their content to understand the project context.
+   - Ask clarifying questions sequentially — one question per turn — whenever the request leaves an obligation ambiguous, leaves a UI or logic decision unspecified, or admits multiple valid interpretations. Do not bundle several questions in one turn.
+   - Prefer multiple-choice questions when the answer space is bounded. Use open-ended questions only when multiple-choice would force a false dichotomy.
+   - When two or three substantially different approaches would all satisfy the request, present those approaches with a short trade-off summary for each and ask the user to pick or redirect, instead of silently choosing one.
+   - The clarification phase ends only when you have enough information to draft contract files that contain no placeholders, no contradictions, and no scope ambiguity.
+4. Run the drafting phase. Before persisting any file:
+   - Present the planned file layout (which files will exist, what each file will cover) and the key obligations of each file as a structured summary, and wait for user approval or redirection.
+   - For non-trivial requests, present the draft of each file (or each section, when a file is large) and wait for approval before moving on. Trivial requests may be presented as a single combined draft.
+   - Update related existing contract files in place when the request affects obligations they already cover, and create new files only for obligations not already covered. Do not duplicate an existing obligation across files.
+5. After approval, run a self-review pass before finalizing each file: re-read the draft and check for placeholders left behind, contradictions with other contract files, ambiguous wording, and scope that drifted beyond what the user requested. Fix any issue in place; if a fix would change the meaning of an already-approved obligation, surface the issue to the user and ask before applying it.
+6. Organize the resulting files in whichever shape best fits the requested product:
+   - A single descriptive file when the product is small.
+   - Multiple files inside contracts/ when the product has clearly separable concerns (for example, a logic file and a UI file).
+   - Subfolders grouping related files when the product has multiple sections (for example, one folder per major feature).
+7. Filenames must be descriptive of their content — the user must be able to tell what each file covers from its name alone.
+
+## Output language
+
+Write contract files in the same natural language as the input request. If the input is in Spanish, the output is in Spanish; if English, English; and so on. Do not translate unless the user says otherwise.
+
+## Idempotency and overwrites
+
+Existing files in contracts/ are not protected. Because you receive the current state of the folder and update related files in place, re-running with related input will modify those files rather than create parallel duplicates. Preserving prior versions is the user's responsibility (typically through version control).`;
+exports.ruleSkillBody = `---
+description: Translate a free-form request into one or more rule markdown files inside the project's rules/ folder.
+---
+
+You are the /flanders-rule skill. Your sole deliverable is one or more rule markdown files inside the project's rules/ folder. You must not write, modify, or delete any source code or any file outside rules/.
+
+## Input resolution
+
+The user invokes you as: /flanders-rule [<data>]
+
+- If <data> is omitted, take the user's natural-language request from the same turn or from subsequent turns of the conversation.
+- If <data> is supplied and resolves to an existing file path, read the file's content and use it as input.
+- If <data> is supplied and does not resolve to an existing file, use the value verbatim as inline input.
+
+## What a rule is
+
+A rule is a markdown document that captures a single, atomic piece of implementation guidance — a constraint, convention, or pattern that the project's code must follow. Each rule file describes exactly one rule.
+
+Bundles of related rules (for example, the multiple obligations that make up SOLID, or the dispose pattern) are modeled as a subfolder under rules/ containing one file per atomic rule inside, never as a single multi-rule file.
+
+The namespace of a rule is its relative path inside rules/ — the combination of its enclosing subfolders and its filename. The namespace is what downstream tooling uses to organize, filter, and reference rules.
+
+Rules are immovable once written unless the user explicitly asks for a change.
+
+## Procedure
+
+1. Resolve the input from the invocation rule above.
+2. Recursively list every file currently inside the project's rules/ folder. Capture relative paths from the project root. When the folder does not exist or is empty, the listing is empty. This listing is exhaustive — do not enumerate files in any other way.
+3. Run the clarification phase before writing anything to disk:
+   - Pick the files relevant to the request from the listing and read their content to understand the project's existing rule set.
+   - Ask the user clarifying questions sequentially — one question per turn — whenever the request leaves a rule ambiguous, leaves the scope of enforcement unspecified, or admits multiple valid interpretations. Do not bundle several questions in one turn.
+   - Prefer multiple-choice questions when the answer space is bounded. Use open-ended questions only when multiple-choice would force a false dichotomy.
+   - When two or three substantially different formulations of a rule would all satisfy the request, present those formulations with a short trade-off summary for each and ask the user to pick or redirect, instead of silently choosing one.
+   - The clarification phase ends only when you have enough information to draft rule files that contain no placeholders, no contradictions, and no scope ambiguity.
+4. Run the drafting phase. Before persisting any file:
+   - Present the planned file layout (which rule files will exist, in which subfolders, and the atomic rule each file captures) as a structured summary, and wait for user approval or redirection.
+   - For non-trivial requests, present the draft of each file (or each section, when a file is large) and wait for approval before moving on. Trivial requests may be presented as a single combined draft.
+   - Update related existing rule files in place when the request affects rules they already cover, and create new files only for rules not already covered. Do not duplicate the same rule across files.
+5. After approval, run the self-review pass before finalizing each file: re-read the draft and check for placeholders left behind, contradictions with other rule files or with existing contracts, ambiguous wording, and scope that drifted beyond what the user requested. Fix any issue in place; if a fix would change the meaning of an already-approved rule, surface the issue to the user and ask before applying it.
+6. Organize the resulting files so that each rule lives in its own file. Use subfolders inside rules/ to group thematically related rules (for example, a testing/ subfolder for testing-related rules, a dependencies/ subfolder for dependency-management rules, a solid/ subfolder with one file per SOLID principle, a disposes/ subfolder with one file per dispose-pattern obligation). A bundle of related rules MUST be modeled as a subfolder of single-rule files, never as one multi-rule file.
+7. Filenames must be descriptive of the single rule the file captures — the user must be able to tell which rule a file pins from its name alone.
+
+## Output language
+
+Write rule files in the same natural language as the input request. If the input is in Spanish, the output is in Spanish; if English, English; and so on. Do not translate unless the user says otherwise.
+
+## Idempotency and overwrites
+
+Existing files in rules/ are not protected. Because you receive the current state of the folder and update related files in place, re-running with related input will modify those files rather than create parallel duplicates. Preserving prior versions is the user's responsibility (typically through version control).`;
+exports.planSkillBody = `---
+description: Produce a contract-aware work plan inside the project's plans/ folder.
+---
+
+You are the /flanders-plan skill. Your sole deliverable is exactly one markdown plan file inside the project's plans/ folder. You must not write, modify, or delete any source code or any file outside plans/.
+
+## Input resolution
+
+The user invokes you as: /flanders-plan [<data>]
+
+- If <data> is omitted, take the user's natural-language request from the conversation.
+- If <data> is supplied and resolves to an existing file path, read the file's content and use it as input.
+- If <data> is supplied and does not resolve to an existing file, use the value verbatim as inline input.
+
+## Procedure
+
+1. Recursively list every file inside the project's contracts/ folder and every file inside the project's rules/ folder. Capture relative paths from the project root. The contracts listing is the canonical reference of contracts for this run; the rules listing is the canonical reference of rules for this run.
+2. Resolve the input from the invocation rule above.
+3. Produce exactly one markdown file inside the project's plans/ folder. The filename must be descriptive of the plan's subject.
+
+## Plan file format
+
+The plan file must follow these rules exactly:
+
+### Task lines
+
+A task is a markdown list item that carries a checkbox and a metrics object at the start of its content. The full shape of a task line is:
+
+    [ ]{"it":0,"ot":0,"t":0} 1.1 TITLE
+
+with the following pieces, in this exact order and spacing:
+
+- A checkbox, in one of two states:
+  - \`[ ]\` — open (not yet implemented).
+  - \`[x]\` — done (already implemented).
+- Immediately after the closing \`]\`, with no whitespace between them, the metrics object (a strict JSON literal — see Task metrics below).
+- A single space after the closing \`}\`.
+- The task number (see Numbering).
+- A single space.
+- The task title.
+
+No malformed variants such as \`[]\`, \`[ x]\`, or \`[X ]\` are permitted. All new tasks are written as open (\`[ ]\`).
+
+### Task metrics
+
+Every leaf task line carries a metrics object \`{"it":0,"ot":0,"t":0}\` at generation time. This is a strict JSON literal with three integer fields: \`it\` (input tokens), \`ot\` (output tokens), and \`t\` (time in seconds), all set to zero for new tasks. The object is placed immediately after the checkbox with no whitespace between \`]\` and \`{\`, and one space between the closing \`}\` and the task number.
+
+### Hierarchy and sub-tasks
+
+- A leaf task (no sub-tasks) carries a checkbox.
+- A parent task (has sub-tasks with their own checkboxes) does NOT carry its own checkbox. It appears as a heading or list item with a title and description, but no checkbox.
+
+Checkboxes appear only on the smallest atomic units of work, never on a unit that aggregates other checkboxed units.
+
+### Numbering
+
+Tasks are numbered hierarchically:
+- Top-level tasks: 1, 2, 3, ...
+- Sub-tasks of task 2: 2.1, 2.2, 2.3, ...
+- Deeper levels follow the same dotted convention.
+
+The numbering is part of the visible task identifier.
+
+### Ordering
+
+Tasks are written in the order they must be implemented, accounting for dependencies. A task that depends on another must appear after the task it depends on.
+
+### Task content
+
+- Write each leaf task with a detailed description and explicit acceptance criteria — the conditions that must be true once the task is implemented for it to be considered complete.
+- Every leaf task carries the initial metrics object \`{"it":0,"ot":0,"t":0}\` literally. Done tasks generated by \`/flanders-plan\` follow the same shape with the same zero values.
+- Choose a granularity that is neither too broad nor too narrow. Tasks must be small enough for a single AI invocation without excessive tokens, but large enough that splitting further would create artificial fragmentation. When in doubt, subdivide.
+- For every leaf task, link the relevant contract file or files by their listed relative path. When the relevant obligation lives in a specific section or line range, reference that section or line range as well.
+- For every leaf task, link the relevant rule file or files by their listed relative path. The planner MUST read every rule file it determines is relevant to the request before drafting the plan; reading the relevant rules is not optional. When a rule's enforcement is bound to a specific scope, reference that scope alongside the file path.
+- Rule selection per task is scope-driven, not topic-driven. Before listing the rule links for a leaf task, walk the rules/ listing and ask: which rule namespaces are in scope for the work this task actually performs? Use the namespace as the scope hint. Heuristics: a task that modifies or adds tests must link every applicable file under \`rules/testing/*\`; a task that creates or modifies anything with timers, listeners, controllers, child processes, or other async lifecycle must link every applicable file under \`rules/disposables/*\`; a task that changes terminal UI or live-region output must link every applicable file under \`rules/ui/*\`. Walk every namespace whose scope could plausibly apply, and pick every file whose obligation could be triggered by the task. Under-linking is costly: the downstream implementor is FAILed by the adversarial reviewer for any global rule that should have applied but was not applied, so when in doubt, link rather than omit.
+- No task may describe work that creates, modifies, deletes, or renames files inside contracts/, inside rules/, or inside plans/ (the bounded checkbox/metrics update that the implement command holds is not available to tasks — see shared/spec-folder-write-authority.md).
+
+### Contract and rule compliance
+
+Never produce a plan that violates any contract or rule on the canonical lists.
+
+## Post-write verification
+
+After writing the plan file, re-read it and verify:
+- The file exists at the expected path inside plans/ and is non-empty.
+- Every task line follows the checkbox shape defined above (every list item carrying a task identifier has a valid \`[ ]\` or \`[x]\` checkbox; no malformed variants).
+- Every leaf task line carries a metrics object literally equal to \`{"it":0,"ot":0,"t":0}\`. The verification re-parses each metrics object with strict JSON, so the check is byte-exact — no extra spaces, no reordered keys, no trailing commas.
+- At least one task line was produced.
+
+If any check fails, fix the file and re-verify instead of leaving a malformed plan on disk.
+
+## Summary
+
+After successful verification, print a summary in chat containing:
+- The plan file path.
+- The plan file's character size.
+- The plan file's total line count.
+- The total number of detected tasks.
+
+## Output language
+
+Write the plan file in the same natural language as the input request, unless the user says otherwise.
+
+## Missing contracts or rules
+
+If the contracts/ folder is missing or empty, warn the user in chat and produce a plan that includes whatever contracts the request implicitly requires before any implementation work. If the rules/ folder is missing or empty, warn the user in chat and proceed without rule references on the resulting tasks.`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2tpbGxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3NraWxscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLGlCQUFpQixHQUM5Qjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7aVVBK0NpVSxDQUFDO0FBRXJULFFBQUEsYUFBYSxHQUMxQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzZUQWdENlQsQ0FBQztBQUVqVCxRQUFBLGFBQWEsR0FDMUI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztvVEF5R29ULENBQUMifQ==

package/lib/ui/BottomBlock.d.ts

@@ -0,0 +1,70 @@
+import type { TimeContext } from "../contexts";
+export type BottomBlockIO = {
+    write(text: string): void;
+    columns(): number;
+    onResize(listener: () => void): () => void;
+};
+export type Activity = "implementing" | "reviewing" | "building" | "testing";
+export type HeaderFields = {
+    indexLabel?: string | null;
+    iteration?: number | null;
+    activity?: Activity | null;
+    taskNumber?: string | null;
+    title?: string | null;
+};
+export type MetricsFields = {
+    task?: {
+        tokens: number;
+        seconds: number;
+    };
+    plan?: {
+        tokens: number;
+        seconds: number;
+    };
+};
+export type WaitKind = "rate-limit";
+export type FooterState = {
+    kind: "blank";
+} | {
+    kind: "working";
+} | {
+    kind: "waiting";
+    waitKind: WaitKind;
+    endTime: number;
+} | {
+    kind: "terminal";
+    label: TerminalLabel;
+};
+export type TerminalLabel = "Done" | "Hard stop" | "Interrupted" | "Failed";
+export declare class BottomBlock {
+    private _io;
+    private _time;
+    private _mounted;
+    private _finalized;
+    private _disposed;
+    private _header;
+    private _metrics;
+    private _footer;
+    private _animFrame;
+    private _animTimer;
+    private _countdownTimer;
+    private _unsubResize;
+    constructor(_io: BottomBlockIO, _time: TimeContext);
+    mount(): void;
+    isFinalized(): boolean;
+    setHeader(fields: HeaderFields): void;
+    setMetrics(fields: MetricsFields): void;
+    setFooter(state: FooterState): void;
+    writeAbove(text: string): void;
+    finalize(label: TerminalLabel): void;
+    dispose(): void;
+    private _cancelTimers;
+    private _startFooterTimer;
+    private _scheduleAnimTick;
+    private _scheduleCountdownTick;
+    private _clearBlock;
+    private _drawBlock;
+    private _renderHeader;
+    private _renderMetrics;
+    private _renderFooter;
+}

package/lib/ui/BottomBlock.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BottomBlock = void 0;
+const formatters_1 = require("./formatters");
+const WAIT_HEADINGS = {
+    "rate-limit": "Waiting rate limit"
+};
+const FRAMES = ["⣋", "⣙", "⣹", "⣸", "⣼", "⣴", "⣦", "⣧", "⣇", "⣏"];
+const FRAME_MS = 200;
+const ORANGE = "\x1b[38;5;208m";
+const RESET = "\x1b[0m";
+const CURSOR_UP_3 = "\x1b[3A";
+const CLEAR_TO_END = "\x1b[J";
+const CR = "\r";
+class BottomBlock {
+    _io;
+    _time;
+    _mounted = false;
+    _finalized = false;
+    _disposed = false;
+    _header = {};
+    _metrics = {};
+    _footer = { kind: "working" };
+    _animFrame = 0;
+    _animTimer = null;
+    _countdownTimer = null;
+    _unsubResize = null;
+    constructor(_io, _time) {
+        this._io = _io;
+        this._time = _time;
+    }
+    mount() {
+        if (this._disposed)
+            return;
+        if (this._mounted)
+            return;
+        this._mounted = true;
+        this._unsubResize = this._io.onResize(() => {
+            this._clearBlock();
+            this._drawBlock();
+        });
+        this._drawBlock();
+        this._startFooterTimer();
+    }
+    isFinalized() {
+        return this._finalized;
+    }
+    setHeader(fields) {
+        if (this._disposed || this._finalized)
+            return;
+        this._header = fields;
+        if (this._mounted) {
+            this._clearBlock();
+            this._drawBlock();
+        }
+    }
+    setMetrics(fields) {
+        if (this._disposed || this._finalized)
+            return;
+        this._metrics = fields;
+        if (this._mounted) {
+            this._clearBlock();
+            this._drawBlock();
+        }
+    }
+    setFooter(state) {
+        if (this._disposed || this._finalized)
+            return;
+        this._cancelTimers();
+        this._footer = state;
+        if (state.kind === "working") {
+            this._animFrame = 0;
+        }
+        if (this._mounted) {
+            this._clearBlock();
+            this._drawBlock();
+            this._startFooterTimer();
+        }
+    }
+    writeAbove(text) {
+        if (this._disposed)
+            return;
+        if (!this._mounted) {
+            this._io.write(text);
+            return;
+        }
+        this._clearBlock();
+        this._io.write(text);
+        this._drawBlock();
+    }
+    finalize(label) {
+        if (this._disposed)
+            return;
+        if (this._finalized)
+            return;
+        this._finalized = true;
+        this._cancelTimers();
+        this._footer = { kind: "terminal", label };
+        if (this._unsubResize) {
+            this._unsubResize();
+            this._unsubResize = null;
+        }
+        if (this._mounted) {
+            this._clearBlock();
+            this._drawBlock();
+            this._io.write("\n");
+        }
+    }
+    dispose() {
+        if (this._disposed)
+            return;
+        this._disposed = true;
+        this._cancelTimers();
+        if (this._unsubResize) {
+            this._unsubResize();
+            this._unsubResize = null;
+        }
+    }
+    _cancelTimers() {
+        if (this._animTimer) {
+            this._animTimer.cancel();
+            this._animTimer = null;
+        }
+        if (this._countdownTimer) {
+            this._countdownTimer.cancel();
+            this._countdownTimer = null;
+        }
+    }
+    _startFooterTimer() {
+        if (this._footer.kind === "working") {
+            this._scheduleAnimTick();
+        }
+        else if (this._footer.kind === "waiting") {
+            this._scheduleCountdownTick();
+        }
+    }
+    _scheduleAnimTick() {
+        this._animTimer = this._time.setTimeout(() => {
+            this._animTimer = null;
+            if (this._disposed || this._finalized || this._footer.kind !== "working")
+                return;
+            this._animFrame = (this._animFrame + 1) % FRAMES.length;
+            this._clearBlock();
+            this._drawBlock();
+            this._scheduleAnimTick();
+        }, FRAME_MS);
+    }
+    _scheduleCountdownTick() {
+        this._countdownTimer = this._time.setTimeout(() => {
+            this._countdownTimer = null;
+            if (this._disposed || this._finalized || this._footer.kind !== "waiting")
+                return;
+            this._clearBlock();
+            this._drawBlock();
+            this._scheduleCountdownTick();
+        }, 1000);
+    }
+    _clearBlock() {
+        this._io.write(CURSOR_UP_3 + CR + CLEAR_TO_END);
+    }
+    _drawBlock() {
+        const cols = Math.max(0, this._io.columns());
+        const separator = formatters_1.SEPARATOR_GLYPH.repeat(cols);
+        const header = this._renderHeader(cols);
+        const metrics = this._renderMetrics(cols);
+        const footer = this._renderFooter();
+        this._io.write(separator + "\n" + header + "\n" + metrics + "\n" + footer);
+    }
+    _renderHeader(cols) {
+        return (0, formatters_1.formatHeaderLine)(this._header.indexLabel ?? null, this._header.iteration ?? null, this._header.activity ?? null, this._header.taskNumber ?? null, this._header.title ?? null, cols);
+    }
+    _renderMetrics(cols) {
+        return (0, formatters_1.formatMetricsLine)(this._metrics.task, this._metrics.plan, cols);
+    }
+    _renderFooter() {
+        switch (this._footer.kind) {
+            case "blank":
+                return "";
+            case "working":
+                return `${ORANGE}${FRAMES[this._animFrame]} Working${RESET}`;
+            case "waiting": {
+                const remaining = Math.max(0, this._footer.endTime - this._time.now());
+                const dateStr = (0, formatters_1.formatDateTime)(new Date(this._footer.endTime));
+                const countdown = (0, formatters_1.formatCountdown)(remaining);
+                return `${ORANGE}${WAIT_HEADINGS[this._footer.waitKind]} — ${dateStr} — ${countdown}${RESET}`;
+            }
+            case "terminal":
+                return `${ORANGE}${this._footer.label}${RESET}`;
+        }
+    }
+}
+exports.BottomBlock = BottomBlock;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BottomBlock.js","sourceRoot":"","sources":["../../src/ui/BottomBlock.ts"],"names":[],"mappings":"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"}

package/lib/ui/formatters.d.ts

@@ -0,0 +1,29 @@
+export declare const CYAN = "\u001B[36m";
+export declare const YELLOW = "\u001B[33m";
+export declare const MAGENTA = "\u001B[35m";
+export declare const GREEN = "\u001B[32m";
+export declare const BLUE = "\u001B[34m";
+export declare const DIM = "\u001B[2m";
+export declare const RESET = "\u001B[0m";
+export declare const SEPARATOR_GLYPH = "\u2500";
+export declare function colorize(text: string, code: string): string;
+export type Segment = {
+    text: string;
+    color?: string;
+};
+export declare function renderSegments(segments: Segment[]): string;
+export declare function renderSegmentsToWidth(segments: Segment[], cols: number): string;
+export declare function formatCountdown(remainingMs: number): string;
+export declare function formatDateTime(date: Date): string;
+export declare function truncateToWidth(text: string, cols: number): string;
+export declare function formatTokens(n: number): string;
+export declare function formatActiveTime(seconds: number): string;
+export declare function formatHeaderLine(indexLabel: string | null, iteration: number | null, activity: string | null, taskNumber: string | null | undefined, title: string | null, cols: number): string;
+export type MetricsPair = {
+    tokens: number;
+    seconds: number;
+};
+export declare function formatMetricsLine(task: MetricsPair | undefined, plan: MetricsPair | undefined, cols: number): string;
+export declare function formatSnapshotHeader(indexLabel: string, iteration: number, taskNumber: string | undefined, title: string): string;
+export declare function formatSnapshotMetrics(taskTokens: number, taskSeconds: number, planTokens: number, planSeconds: number): string;
+export declare function formatSnapshotBlock(indexLabel: string, iteration: number, taskNumber: string | undefined, title: string, taskTokens: number, taskSeconds: number, planTokens: number, planSeconds: number, cols: number): string;