indusagi-coding-agent 0.1.59 → 0.1.61

package/dist/types/boot/runners/session.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Boot helper: assemble a {@link SessionConductor} for a non-interactive runner.
+ *
+ * Both the oneshot and the link runners drive a live conductor; this module owns
+ * the one place that turns a {@link BootContext} into one, so the two runners do
+ * not each re-derive the model id and session options. The model is taken from
+ * the invocation when supplied, else resolved to the catalog default through the
+ * {@link ModelMatcher}; the conductor itself is built lazily so no framework agent
+ * is constructed until the first turn runs.
+ */
+import { type SessionConductor } from "../../conductor";
+import type { BootContext } from "../contract";
+/**
+ * Resolve the model id for this run.
+ *
+ * Precedence: an explicit `--model` selector wins; otherwise a current model of a
+ * provider the user has authenticated for (so a fresh launch lands on a model the
+ * stored key can actually call); otherwise the catalog default.
+ *
+ * @param ctx the boot context carrying the parsed invocation
+ * @returns the canonical model id to bind the session to
+ */
+export declare function resolveModelId(ctx: BootContext): string;
+/**
+ * The cwd-scoped session directory under the workspace `sessions/` root.
+ *
+ * Sessions are partitioned per working directory (so `--continue` means "the most
+ * recent session in THIS directory"). The cwd is slugged — every non-alphanumeric
+ * run collapsed to a single dash — and wrapped in `--…--` markers, matching the
+ * on-disk layout. Both the conductor (writer) and {@link SessionLibrary} (reader)
+ * must agree on this, so it lives here and is shared by the repl runner.
+ *
+ * @param sessionsRoot the workspace `sessions/` directory
+ * @param cwd          the run's working directory
+ */
+export declare function sessionScopeDir(sessionsRoot: string, cwd: string): string;
+export declare function buildSessionConductor(ctx: BootContext): Promise<SessionConductor>;
+/**
+ * The prompts a oneshot run submits: the positional first prompt when present,
+ * plus any pass-through tokens that survived flag parsing. Empty when the
+ * invocation carried no request text (the caller decides what to do then).
+ *
+ * @param ctx the boot context carrying the parsed invocation
+ */
+export declare function oneshotPrompts(ctx: BootContext): string[];

package/dist/types/boot/stages.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Boot stage pipeline — the ordered list of {@link Stage} transforms that turn a
+ * bare {@link BootContext} (argv + workspace + brand) into a fully-resolved one
+ * (parsed invocation, materialised directories, applied upgrades, resolved
+ * startup resources, selected runner).
+ *
+ * The pipeline is data, not control flow: {@link STAGES} lists each step in order,
+ * and {@link runStages} folds an *immutable* context through them — every stage
+ * receives a context and returns its successor (built by spreading, never by
+ * mutating). A stage may be async; the fold awaits each in turn so ordering and
+ * side-effect sequencing are deterministic.
+ *
+ * Stage order and intent:
+ *   1. `locate-workspace`  — materialise the resolved {@link Workspace} on disk
+ *      (`createWorkspace` + `ensureDirs`). Pure path computation already happened
+ *      when the initial context was built; this stage only `mkdir`s.
+ *   2. `apply-upgrades`    — fold the idempotent {@link applyUpgrades} registry
+ *      over the workspace (a no-op on an already-current profile).
+ *   3. `build-invocation`  — parse `argv` into the typed {@link Invocation}.
+ *   4. `resolve-resources` — best-effort construct the framework
+ *      settings/auth/model graph; degrade to a minimal object if the framework
+ *      pieces are unavailable.
+ *   5. `select-runner`     — no-op transform that exists for symmetry and tracing
+ *      (the actual dispatch happens in {@link "./boot"} after the pipeline, so the
+ *      selected runner can own the exit code). Kept in the list so the ordered
+ *      pipeline reads as the full launch sequence.
+ */
+import type { BootContext, Stage } from "./contract";
+/**
+ * Materialise the resolved workspace directories on disk.
+ *
+ * The {@link BootContext.workspace} was already computed (pure) when the initial
+ * context was assembled; this stage only ensures the directory subset exists so
+ * later stages and runners can write into it. Returns the same context (the
+ * workspace record is unchanged — only the filesystem side-effects happen here).
+ */
+declare const locateWorkspace: Stage;
+/**
+ * Run any pending one-time profile upgrades, idempotently.
+ *
+ * Folds the upgrade registry over the workspace. The driver is non-fatal: a step
+ * that fails is reported and retried on a later launch, never aborting boot. The
+ * context is returned unchanged (upgrades touch the filesystem, not the context).
+ */
+declare const upgrade: Stage;
+/**
+ * Parse `argv` into the typed {@link Invocation} and thread it onto the context.
+ *
+ * The initial context carries a placeholder invocation (the bootstrapper cannot
+ * know the mode before parsing); this stage replaces it with the real parse.
+ */
+declare const buildInvocation: Stage;
+/**
+ * Best-effort assembly of the startup resource graph.
+ *
+ * Where the rebuilt framework owns a concept, the field is constructed from it:
+ * {@link StartupResources.settings} from the framework's `DEFAULT_SETTINGS`, and
+ * {@link StartupResources.models} from the framework's `ModelRegistry`. The
+ * credential graph has no framework type yet, so it is an empty placeholder until
+ * Phase 2. If a framework piece cannot be loaded, the stage degrades to a minimal
+ * resources object built from empty literals rather than failing the boot — the
+ * shape is what later phases depend on, and they fill it in.
+ */
+declare const resolveResources: Stage;
+/**
+ * Marker / tracing stage for runner selection.
+ *
+ * The real dispatch is performed by {@link "./boot"} after the pipeline so the
+ * chosen runner can own the process exit code; this stage exists to keep the
+ * ordered pipeline a faithful description of the launch sequence and to give the
+ * selection step a name for tracing. It returns the context unchanged.
+ */
+declare const selectRunnerStage: Stage;
+/**
+ * The launch pipeline, in execution order. Folded by {@link runStages}.
+ */
+export declare const STAGES: readonly Stage[];
+/**
+ * Fold an ordered list of {@link Stage} transforms over an immutable
+ * {@link BootContext}.
+ *
+ * Each stage receives the current context and returns its successor; the result
+ * of one stage is the input to the next. Awaits every stage so async ordering is
+ * deterministic. The input `initial` is never mutated — stages produce new
+ * contexts by spreading.
+ *
+ * @param initial The seed context (argv + workspace + brand + placeholder fields).
+ * @param stages  The ordered transforms to apply; defaults to {@link STAGES}.
+ * @returns The fully-resolved context after every stage has run.
+ */
+export declare function runStages(initial: BootContext, stages?: readonly Stage[]): Promise<BootContext>;
+export { locateWorkspace, upgrade, buildInvocation, resolveResources, selectRunnerStage, };

package/dist/types/boot/upgrade/apply.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Upgrade driver — folds the ordered {@link UPGRADES} registry over a
+ * {@link Workspace}, exactly once per step.
+ *
+ * The driver is the only place that knows about the *marker file*: a small JSON
+ * record under the profile directory listing the ids of upgrades that have
+ * already run. Each registry step is skipped if its id is present in the marker;
+ * otherwise it is applied and, on success, its id is appended and the marker is
+ * persisted. A step that throws is *not* recorded (so it is retried next launch)
+ * and is reported as a warning rather than aborting the remaining steps — one
+ * bad migration must never wedge startup.
+ *
+ * The result is purely informational: {@link UpgradeReport.applied} lists ids run
+ * *this* invocation (empty on an already-current profile), and
+ * {@link UpgradeReport.warnings} carries human-readable notes for any step that
+ * failed. Callers typically log both and continue.
+ */
+import type { Workspace } from "../contract";
+/**
+ * The outcome of an {@link applyUpgrades} pass.
+ *
+ *   - `applied`  — ids of upgrades that ran successfully *this* invocation, in
+ *     apply order. Empty when the profile was already current.
+ *   - `warnings` — one entry per step that threw, naming the step and its error.
+ *     Non-fatal: applying continues past a failed step.
+ */
+export interface UpgradeReport {
+    /** Ids successfully applied during this call, in order. */
+    readonly applied: string[];
+    /** Human-readable notes for steps that failed (non-fatal). */
+    readonly warnings: string[];
+}
+/**
+ * Apply every not-yet-applied upgrade in {@link UPGRADES}, in registry order,
+ * recording each success in the marker file so it never runs again.
+ *
+ * Steps already named in the marker are skipped. A step that throws is recorded
+ * as a warning, left unmarked (so it is retried on a later launch), and does not
+ * block the remaining steps. The marker is rewritten after each success, so a
+ * crash mid-pass still preserves the progress made so far.
+ *
+ * @param ws The resolved, absolute on-disk layout to upgrade.
+ * @returns The ids applied this pass and any non-fatal warnings.
+ */
+export declare function applyUpgrades(ws: Workspace): Promise<UpgradeReport>;

package/dist/types/boot/upgrade/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Upgrade subsystem — public barrel.
+ *
+ * Surfaces the ordered, idempotent profile-upgrade registry and its driver.
+ * Boot consumers import {@link applyUpgrades} to run pending one-time migrations
+ * and the {@link UPGRADES} registry / {@link Upgrade} type for inspection and
+ * testing. The marker-file bookkeeping is an internal detail of the driver and
+ * is not re-exported.
+ */
+export type { Upgrade } from "./upgrades";
+export { UPGRADES, foldCredentials, reshelveTranscripts, relocateBinaries, renamePromptDir, projectTranscriptDirName, } from "./upgrades";
+export type { UpgradeReport } from "./apply";
+export { applyUpgrades } from "./apply";

package/dist/types/boot/upgrade/upgrades.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Upgrade registry — the ordered, idempotent catalog of one-time profile
+ * migrations.
+ *
+ * This module replaces a bag of magic constants and inlined `try/catch`
+ * migration blocks with a *registry*: an explicit, ordered list of named
+ * {@link Upgrade} steps. Each step owns a stable {@link Upgrade.id}, a one-line
+ * {@link Upgrade.describe}, and an idempotent {@link Upgrade.apply}. The driver
+ * ({@link "./apply"}) folds over the list in order, recording the ids it has run
+ * in a marker file so a step never runs twice — re-running the whole registry on
+ * an already-upgraded profile is a no-op.
+ *
+ * Idempotence contract (every step must honor it):
+ *   - Detect "already done" cheaply and return early without side effects.
+ *   - Treat a *missing* source (the thing being migrated from) as success — the
+ *     profile is either fresh or already past this point.
+ *   - Never destroy data: relocations move-or-skip, never overwrite a live
+ *     destination; the legacy source is suffixed, not deleted.
+ *
+ * The seeded steps fold the legacy on-disk layout into the current one:
+ *   1. {@link foldCredentials}   — legacy split auth → one secure `auth.json`.
+ *   2. {@link reshelveTranscripts} — loose session files → per-cwd `sessions/`.
+ *   3. {@link relocateBinaries}  — managed `fd`/`rg` helpers → the `bin/` dir.
+ *   4. {@link renamePromptDir}   — legacy `commands/` dir → `prompts/`.
+ *
+ * Session-directory encoding note: step 2 must place a transcript under the
+ * *same* per-cwd directory name the framework's session manager would compute.
+ * The framework publishes no standalone encoder for that name (the encoding is
+ * private to its session manager), so this module uses a clearly-named local
+ * helper, {@link projectTranscriptDirName}, rather than re-deriving the
+ * framework's private per-cwd directory encoding. If the framework later exports
+ * an encoder, swap the helper for the import without touching the step logic.
+ */
+import type { Workspace } from "../contract";
+/**
+ * One ordered, idempotent profile-layout upgrade.
+ *
+ * An upgrade is pure data plus one async effect. The registry order is the
+ * apply order; the {@link id} is the durable key recorded in the marker file
+ * once {@link apply} completes, so it must be stable across releases (renaming an
+ * id re-runs the step). {@link apply} must be safe to invoke against a profile in
+ * any state — fresh, partially-migrated, or fully-migrated.
+ */
+export interface Upgrade {
+    /** Durable identifier recorded once this step has run. Never rename. */
+    readonly id: string;
+    /** One-line human summary for logs and `--verbose` output. */
+    readonly describe: string;
+    /**
+     * Perform the upgrade against the resolved {@link Workspace}. Must be
+     * idempotent: detect "already applied" and return without side effects.
+     *
+     * @param ws The resolved, absolute on-disk layout.
+     */
+    apply(ws: Workspace): Promise<void>;
+}
+/**
+ * Compute the per-project transcript sub-directory *name* for a working
+ * directory.
+ *
+ * This deliberately does not reproduce the framework session manager's private
+ * encoding character-for-character; the framework exposes no public encoder to
+ * import, so this is the documented local fallback. It produces a single,
+ * filesystem-safe directory leaf that is stable for a given absolute `cwd`:
+ * path separators, drive colons, and any other non-portable characters collapse
+ * to a single token, and a short content hash is appended so two distinct paths
+ * that happen to fold to the same token never collide.
+ *
+ * The output is used only when *relocating a loose legacy transcript* into the
+ * sessions tree; live sessions are always created by the framework itself, so
+ * this helper never competes with the framework for the canonical name.
+ *
+ * @param cwd Absolute working directory the transcript belongs to.
+ * @returns A safe directory leaf such as `proj-Users-me-app-1a2b3c4d`.
+ */
+export declare function projectTranscriptDirName(cwd: string): string;
+/**
+ * Fold a legacy split credential layout — a standalone `oauth.json` plus an
+ * `apiKeys` block embedded in `settings.json` — into the single consolidated
+ * `auth.json`, written with owner-only (`0o600`-equivalent) permissions.
+ *
+ * Idempotent: if `auth.json` already exists, nothing is touched. After a
+ * successful fold the legacy `oauth.json` is suffixed (`oauth.json.retired`) and
+ * the `apiKeys` block is removed from `settings.json`, so a second run finds no
+ * legacy sources and the existing `auth.json` short-circuits it regardless.
+ */
+export declare const foldCredentials: Upgrade;
+/**
+ * Relocate loose `*.jsonl` transcripts that were written directly under the
+ * profile root (a legacy layout) into the structured per-cwd sessions tree:
+ * `sessions/<projectDirName>/<file>`.
+ *
+ * A loose file is recognized as a transcript by a first-line header of
+ * `type: "session"`. The destination project directory is derived from the
+ * header's recorded `cwd` via {@link projectTranscriptDirName} (the framework
+ * owns no public encoder to delegate to — see this module's header). Each move
+ * is skip-on-clobber, so re-running never overwrites an already-relocated
+ * transcript, and once no loose transcripts remain the step is a pure no-op.
+ */
+export declare const reshelveTranscripts: Upgrade;
+/**
+ * Relocate the managed native helper binaries (`fd`, `rg`, and their Windows
+ * `.exe` forms) from the legacy `tools/` directory into the canonical managed
+ * `bin/` directory ({@link Workspace.binDir}).
+ *
+ * Each binary is moved skip-on-clobber and independently, so a partially-moved
+ * state self-heals on the next run and an already-relocated layout (or a fresh
+ * install with no legacy `tools/`) is a no-op.
+ */
+export declare const relocateBinaries: Upgrade;
+/**
+ * Rename the legacy command-template directory (`commands/`) to the current
+ * prompt-template directory ({@link Workspace.promptsDir}).
+ *
+ * Idempotent: if the destination already exists the rename is skipped (the
+ * profile is already on the current layout), and if the legacy directory is
+ * absent there is nothing to do. The rename is whole-directory and
+ * non-destructive — a live `prompts/` is never replaced.
+ */
+export declare const renamePromptDir: Upgrade;
+/**
+ * The ordered list of upgrades. Apply order is array order; ids are the durable
+ * marker keys. Append new steps to the end — never reorder or rename existing
+ * ids, as that would re-run already-applied migrations.
+ */
+export declare const UPGRADES: readonly Upgrade[];

package/dist/types/briefing/briefing.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Briefing subsystem — Phase 9 behavioral tests.
+ *
+ * Three concerns, exercised purely (the only I/O is one temp `SKILL.md`):
+ *   1. {@link composeBriefing} — the declarative section pipeline emits the
+ *      ordered sections rendered in this rebuild's OWN voice (we assert on our
+ *      section headings and re-authored guidance, never on any carried-over
+ *      upstream sentence).
+ *   2. {@link scanMacroBody} / {@link applyMacros} — the single-pass `$arg`
+ *      scanner substitutes `$name` and `${name}` forms in one left-to-right scan
+ *      and leaves unknown tokens as literal text.
+ *   3. {@link loadSkillCards} — a sample `SKILL.md` under a tmpdir parses into a
+ *      validated CapabilityCard.
+ */
+export {};

package/dist/types/briefing/compose.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Briefing composer — the declarative system-prompt pipeline.
+ *
+ * The system prompt is assembled from an ordered list of {@link BriefingSection}
+ * descriptors, not a string template with `{{TOKEN}}` holes. Each section decides
+ * for itself whether it contributes to a given {@link BriefingContext} (its
+ * `applies` predicate) and renders its own fragment (its `render`). The composer
+ * is a small reducer: it walks the recipe in order, keeps the applicable
+ * sections, renders them, drops empties, and joins with blank-line gaps. Adding,
+ * removing, or reordering a section is a data edit to {@link BRIEFING_SECTIONS},
+ * never a change to the composer.
+ *
+ * Every guideline, tool note, and heading below is authored for this rebuild.
+ * The *set* of sections (role, tools, working guidance, task tracking, delegates,
+ * connectors, project context, skills, footer) follows the well-known coding-
+ * agent shape; the wording is the briefing's own.
+ */
+import type { Briefing, BriefingContext, BriefingInputs } from "./contract";
+/**
+ * The default briefing recipe, in render order. Swap or reorder entries to
+ * reshape the prompt without touching {@link composeBriefing}.
+ */
+export declare const BRIEFING_SECTIONS: Briefing;
+/**
+ * Fold a section recipe and a context into the final briefing string.
+ *
+ * Accepts either a plain {@link BriefingContext} (using the default
+ * {@link BRIEFING_SECTIONS} recipe) or a full {@link BriefingInputs} bundle that
+ * names its own sections and optional `prelude` / `append` text. The composer
+ * keeps each section whose `applies` predicate is satisfied (or absent), renders
+ * it, discards empty fragments, and joins the rest with blank-line gaps. Optional
+ * `prelude` and `append` bracket the rendered sections.
+ *
+ * @param input either the render context, or a full inputs bundle
+ * @returns the assembled system-prompt string
+ */
+export declare function composeBriefing(input: BriefingContext | BriefingInputs): string;