voratiq 0.1.0-beta.21 → 0.1.0-beta.22

package/dist/utils/git.d.ts

@@ -31,7 +31,7 @@ export declare function removeWorktree(options: {
     root: string;
     worktreePath: string;
 }): Promise<void>;
-export declare function gitAddAll(cwd: string): Promise<void>;
+export declare function gitAddAll(cwd: string, excludedPaths?: readonly string[]): Promise<void>;
 export declare function gitHasStagedChanges(cwd: string): Promise<boolean>;
 export interface GitCommitOptions {
     cwd: string;

package/dist/utils/git.js

@@ -20,7 +20,7 @@ export async function assertGitRepository(root) {
         const repoRoot = await getGitRepositoryRoot(root);
         if (repoRoot !== null) {
             // We're in a repo but not at the root
-            throw new GitRepositoryError("Run `voratiq init` from the repository root.", "not_repository_root");
+            throw new GitRepositoryError("Run `voratiq` from the repository root.", "not_repository_root", repoRoot);
         }
         // No git repository exists at all
         throw new GitRepositoryError("No git repository found. Run `git init` or switch to an existing repository.", "no_repository");
@@ -80,8 +80,15 @@ export async function removeWorktree(options) {
         cwd: root,
     });
 }
-export async function gitAddAll(cwd) {
+export async function gitAddAll(cwd, excludedPaths) {
     await runGitCommand(["add", "-A"], { cwd });
+    const existingExcludedPaths = await resolveExistingGitPaths(cwd, excludedPaths);
+    if (existingExcludedPaths.length === 0) {
+        return;
+    }
+    await runGitCommand(["reset", "--quiet", "HEAD", "--", ...existingExcludedPaths], {
+        cwd,
+    });
 }
 export async function gitHasStagedChanges(cwd) {
     const output = await runGitCommand(["diff", "--cached", "--name-only"], {
@@ -146,3 +153,19 @@ function isHeadMissing(error) {
     const isHeadExitCode = code === 128 || code === "128";
     return headMissingMessage || (isHeadExitCode && normalized.includes("head"));
 }
+async function resolveExistingGitPaths(cwd, paths) {
+    if (!paths || paths.length === 0) {
+        return [];
+    }
+    const existing = [];
+    for (const path of paths) {
+        try {
+            await access(join(cwd, path), F_OK);
+            existing.push(path);
+        }
+        catch {
+            // Ignore missing excluded paths so git add works across repos and tests.
+        }
+    }
+    return existing;
+}

package/dist/utils/list-target.d.ts

@@ -0,0 +1,4 @@
+import type { ListJsonTargetRef } from "../contracts/list.js";
+export declare const TARGET_TABLE_PREVIEW_LENGTH = 32;
+export declare function formatTargetDisplay(target: ListJsonTargetRef): string;
+export declare function formatTargetTablePreview(target: ListJsonTargetRef, maxLength?: number): string;

package/dist/utils/list-target.js

@@ -0,0 +1,35 @@
+const TARGET_SEPARATOR = ":";
+const TARGET_ELISION = "...";
+export const TARGET_TABLE_PREVIEW_LENGTH = 32;
+export function formatTargetDisplay(target) {
+    if (target.kind === "file") {
+        return `file:${target.path}`;
+    }
+    if (target.agentId) {
+        return `${target.kind}:${target.sessionId}:${target.agentId}`;
+    }
+    return `${target.kind}:${target.sessionId}`;
+}
+export function formatTargetTablePreview(target, maxLength = TARGET_TABLE_PREVIEW_LENGTH) {
+    const display = formatTargetDisplay(target);
+    return middleElideTargetDisplay(display, maxLength);
+}
+function middleElideTargetDisplay(display, maxLength) {
+    if (display.length <= maxLength) {
+        return display;
+    }
+    if (maxLength <= TARGET_ELISION.length) {
+        return display.slice(0, maxLength);
+    }
+    const separatorIndex = display.indexOf(TARGET_SEPARATOR);
+    const prefixLength = separatorIndex >= 0 ? separatorIndex + 1 : 0;
+    const prefix = display.slice(0, prefixLength);
+    const suffixSource = display.slice(prefixLength);
+    const availableSuffixLength = maxLength - prefix.length - TARGET_ELISION.length;
+    if (availableSuffixLength <= 0) {
+        const prefixBudget = Math.max(0, maxLength - TARGET_ELISION.length);
+        return `${display.slice(0, prefixBudget)}${TARGET_ELISION}`;
+    }
+    const suffix = suffixSource.slice(-availableSuffixLength);
+    return `${prefix}${TARGET_ELISION}${suffix}`;
+}

package/dist/utils/terminal.d.ts

@@ -3,3 +3,4 @@ export interface InteractiveShellOptions {
     output?: NodeJS.WriteStream | null;
 }
 export declare function isInteractiveShell(options?: InteractiveShellOptions): boolean;
+export declare function normalizeInteractiveTerm(env: NodeJS.ProcessEnv, options?: InteractiveShellOptions): string | undefined;

package/dist/utils/terminal.js

@@ -1,5 +1,16 @@
+const FALLBACK_INTERACTIVE_TERM = "xterm-256color";
 export function isInteractiveShell(options = {}) {
     const input = options.input ?? process.stdin;
     const output = options.output ?? process.stdout;
     return Boolean(input?.isTTY && output?.isTTY);
 }
+export function normalizeInteractiveTerm(env, options = {}) {
+    if (!isInteractiveShell(options)) {
+        return env.TERM;
+    }
+    const term = env.TERM?.trim();
+    if (!term || term.toLowerCase() === "dumb") {
+        return FALLBACK_INTERACTIVE_TERM;
+    }
+    return env.TERM;
+}

package/dist/workspace/chat/artifacts.d.ts

@@ -12,6 +12,7 @@ export interface PreserveChatArtifactsOptions {
     agentRoot: string;
     searchEnv?: NodeJS.ProcessEnv;
     baseline?: ProviderTranscriptBaseline;
+    selectionHint?: ProviderTranscriptSelectionHint;
 }
 export interface ProviderTranscriptSnapshotEntry {
     path: string;
@@ -19,5 +20,11 @@ export interface ProviderTranscriptSnapshotEntry {
     mtimeMs: number;
 }
 export type ProviderTranscriptBaseline = readonly ProviderTranscriptSnapshotEntry[];
+export interface CodexSessionMetaSelectionHint {
+    strategy: "codex-session-meta";
+    cwd: string;
+    minStartedAt?: string;
+}
+export type ProviderTranscriptSelectionHint = CodexSessionMetaSelectionHint;
 export declare function snapshotProviderTranscripts(options: Omit<PreserveChatArtifactsOptions, "baseline">): Promise<ProviderTranscriptBaseline>;
 export declare function preserveProviderChatTranscripts(options: PreserveChatArtifactsOptions): Promise<ChatArtifactCaptureResult>;

package/dist/workspace/chat/artifacts.js

@@ -42,7 +42,20 @@ export async function preserveProviderChatTranscripts(options) {
         };
     }
     const existing = await locateExistingChatArtifact(agentRoot);
-    const selection = selectTranscriptFiles(candidatePaths);
+    let selection;
+    try {
+        selection = await selectTranscriptFiles({
+            providerId,
+            transcriptPaths: candidatePaths,
+            selectionHint: options.selectionHint,
+        });
+    }
+    catch (error) {
+        return {
+            status: "error",
+            error: error instanceof Error ? error : new Error(String(error)),
+        };
+    }
     if (!selection) {
         if (existing !== undefined) {
             return {
@@ -101,10 +114,21 @@ async function locateExistingChatArtifact(agentRoot) {
     }
     return undefined;
 }
-function selectTranscriptFiles(transcriptPaths) {
+async function selectTranscriptFiles(options) {
+    const { providerId, transcriptPaths, selectionHint } = options;
     const jsonlFiles = transcriptPaths.filter((path) => path.toLowerCase().endsWith(".jsonl"));
     if (jsonlFiles.length > 0) {
-        return { format: "jsonl", files: [...jsonlFiles].sort() };
+        const selectedJsonlFiles = await filterJsonlTranscriptFilesByHint({
+            providerId,
+            files: jsonlFiles,
+            selectionHint,
+        });
+        if (selectedJsonlFiles.length > 0) {
+            return { format: "jsonl", files: selectedJsonlFiles };
+        }
+        if (selectionHint) {
+            return undefined;
+        }
     }
     const jsonFiles = transcriptPaths
         .filter((path) => path.toLowerCase().endsWith(".json"))
@@ -114,6 +138,73 @@ function selectTranscriptFiles(transcriptPaths) {
     }
     return undefined;
 }
+async function filterJsonlTranscriptFilesByHint(options) {
+    const sortedFiles = [...options.files].sort();
+    const hint = options.selectionHint;
+    if (!hint) {
+        return sortedFiles;
+    }
+    if (options.providerId !== "codex" ||
+        hint.strategy !== "codex-session-meta") {
+        return sortedFiles;
+    }
+    const matchingFiles = [];
+    for (const file of sortedFiles) {
+        const metadata = await readCodexSessionMetadata(file);
+        if (!metadata) {
+            continue;
+        }
+        if (metadata.cwd !== hint.cwd) {
+            continue;
+        }
+        if (hint.minStartedAt &&
+            metadata.startedAt &&
+            metadata.startedAt < hint.minStartedAt) {
+            continue;
+        }
+        matchingFiles.push(file);
+    }
+    if (matchingFiles.length === 1) {
+        return matchingFiles;
+    }
+    if (matchingFiles.length > 1) {
+        throw new Error(`Ambiguous Codex transcript provenance for cwd \`${hint.cwd}\`: ${matchingFiles.join(", ")}`);
+    }
+    return [];
+}
+async function readCodexSessionMetadata(path) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const lines = raw.split(/\r?\n/u);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        const record = parsed;
+        if (record.type !== "session_meta") {
+            continue;
+        }
+        const payload = record.payload?.payload ?? record.payload;
+        return {
+            cwd: typeof payload?.cwd === "string" ? payload.cwd : undefined,
+            startedAt: typeof payload?.timestamp === "string" ? payload.timestamp : undefined,
+        };
+    }
+    return undefined;
+}
 async function bundleJsonTranscripts(options) {
     const { files, artifactPath, agentRoot, providerId } = options;
     if (files.length === 0) {

package/dist/workspace/errors.js

@@ -1,6 +1,6 @@
 import { HintedError } from "../utils/errors.js";
 const DEFAULT_WORKSPACE_HINT = [
-    "Run `voratiq init` to configure the workspace.",
+    "Run `voratiq doctor --fix` to repair workspace setup.",
 ];
 export class WorkspaceError extends HintedError {
     constructor(message, detailLines = [], hintLines = DEFAULT_WORKSPACE_HINT) {
@@ -29,7 +29,7 @@ export class WorkspaceWrongTypeEntryError extends WorkspaceError {
 export class WorkspaceNotInitializedError extends WorkspaceError {
     missingEntries;
     constructor(missingEntries) {
-        super("Voratiq workspace is not initialized.", buildMissingEntryDetailLines(missingEntries), ["Run `voratiq init` from the repository root, then retry."]);
+        super("Voratiq workspace is not initialized.", buildMissingEntryDetailLines(missingEntries), ["Run `voratiq doctor --fix` to repair workspace setup."]);
         this.missingEntries = missingEntries;
         this.name = "WorkspaceNotInitializedError";
     }

package/dist/workspace/managed-state.d.ts

@@ -0,0 +1,32 @@
+import type { AgentPreset } from "../configs/agents/defaults.js";
+export declare const MANAGED_STATE_VERSION = 1;
+export interface ManagedConfigFingerprint {
+    fingerprint: string;
+}
+export interface ManagedAgentsFingerprint extends ManagedConfigFingerprint {
+    managedEntriesFingerprint: string;
+}
+export interface ManagedOrchestrationFingerprint extends ManagedConfigFingerprint {
+    preset: AgentPreset;
+}
+export interface ManagedStateSnapshot {
+    version: number;
+    configs: {
+        agents?: ManagedAgentsFingerprint;
+        orchestration?: ManagedOrchestrationFingerprint;
+    };
+}
+export interface UpdateManagedStateOptions {
+    agentsContent?: string;
+    orchestrationContent?: string;
+    orchestrationPreset?: AgentPreset;
+}
+export declare function readManagedState(root: string): Promise<ManagedStateSnapshot | undefined>;
+export declare function updateManagedState(root: string, options: UpdateManagedStateOptions): Promise<{
+    path: string;
+    created: boolean;
+    updated: boolean;
+}>;
+export declare function computeManagedFingerprint(content: string): string;
+export declare function isManagedFingerprintMatch(fingerprint: ManagedConfigFingerprint | undefined, content: string): boolean;
+export declare function isManagedAgentsFingerprintMatch(fingerprint: ManagedAgentsFingerprint | undefined, content: string): boolean;

package/dist/workspace/managed-state.js

@@ -0,0 +1,103 @@
+import { createHash } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import { getAgentDefaultId, getSupportedAgentDefaults, } from "../configs/agents/defaults.js";
+import { readAgentsConfig } from "../configs/agents/loader.js";
+import { isFileSystemError } from "../utils/fs.js";
+import { normalizeConfigText } from "../utils/yaml.js";
+import { resolveWorkspacePath, VORATIQ_MANAGED_STATE_FILE, } from "./structure.js";
+import { serializeAgentsConfigEntries } from "./templates.js";
+export const MANAGED_STATE_VERSION = 1;
+export async function readManagedState(root) {
+    const path = resolveWorkspacePath(root, VORATIQ_MANAGED_STATE_FILE);
+    try {
+        const content = await readFile(path, "utf8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (isFileSystemError(error) && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export async function updateManagedState(root, options) {
+    const path = resolveWorkspacePath(root, VORATIQ_MANAGED_STATE_FILE);
+    const existing = await readManagedState(root);
+    const next = existing
+        ? {
+            ...existing,
+            version: MANAGED_STATE_VERSION,
+            configs: { ...existing.configs },
+        }
+        : { version: MANAGED_STATE_VERSION, configs: {} };
+    if (options.agentsContent !== undefined) {
+        next.configs.agents = {
+            fingerprint: computeManagedFingerprint(options.agentsContent),
+            managedEntriesFingerprint: computeManagedAgentsEntriesFingerprint(options.agentsContent),
+        };
+    }
+    if (options.orchestrationContent !== undefined) {
+        next.configs.orchestration = {
+            fingerprint: computeManagedFingerprint(options.orchestrationContent),
+            preset: options.orchestrationPreset ?? "pro",
+        };
+    }
+    const serialized = serializeManagedState(next);
+    const previousSerialized = existing ? serializeManagedState(existing) : "";
+    if (serialized === previousSerialized) {
+        return { path, created: false, updated: false };
+    }
+    await writeFile(path, serialized, "utf8");
+    return {
+        path,
+        created: existing === undefined,
+        updated: true,
+    };
+}
+export function computeManagedFingerprint(content) {
+    return createHash("sha256")
+        .update(normalizeConfigText(content), "utf8")
+        .digest("hex");
+}
+export function isManagedFingerprintMatch(fingerprint, content) {
+    if (!fingerprint) {
+        return false;
+    }
+    return fingerprint.fingerprint === computeManagedFingerprint(content);
+}
+export function isManagedAgentsFingerprintMatch(fingerprint, content) {
+    if (!fingerprint) {
+        return false;
+    }
+    return (fingerprint.fingerprint === computeManagedFingerprint(content) ||
+        fingerprint.managedEntriesFingerprint ===
+            computeManagedAgentsEntriesFingerprint(content));
+}
+function serializeManagedState(state) {
+    return `${JSON.stringify(state, null, 2)}\n`;
+}
+function computeManagedAgentsEntriesFingerprint(content) {
+    const config = readAgentsConfig(content);
+    const entriesById = new Map();
+    for (const entry of config.agents) {
+        entriesById.set(entry.id, normalizeAgentEntry(entry));
+    }
+    const managedEntries = getSupportedAgentDefaults()
+        .map((template) => entriesById.get(getAgentDefaultId(template)))
+        .filter((entry) => entry !== undefined);
+    return createHash("sha256")
+        .update(normalizeConfigText(`agents:\n${serializeAgentsConfigEntries(managedEntries)}`), "utf8")
+        .digest("hex");
+}
+function normalizeAgentEntry(entry) {
+    return {
+        id: entry.id,
+        provider: entry.provider,
+        model: entry.model,
+        enabled: entry.enabled !== false,
+        binary: entry.binary ?? "",
+        extraArgs: entry.extraArgs && entry.extraArgs.length > 0
+            ? [...entry.extraArgs]
+            : undefined,
+    };
+}

package/dist/workspace/setup.js

@@ -1,5 +1,5 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve as resolveAbsolute } from "node:path";
 import { readAgentsConfig } from "../configs/agents/loader.js";
 import { loadEnvironmentConfig, } from "../configs/environment/loader.js";
 import { buildDefaultOrchestrationTemplate } from "../configs/orchestration/bootstrap.js";
@@ -7,7 +7,8 @@ import { toErrorMessage } from "../utils/errors.js";
 import { isDirectory, isFile, pathExists } from "../utils/fs.js";
 import { relativeToRoot } from "../utils/path.js";
 import { WorkspaceMissingEntryError, WorkspaceNotInitializedError, WorkspaceSetupError, WorkspaceWrongTypeEntryError, } from "./errors.js";
-import { resolveWorkspacePath, VORATIQ_AGENTS_FILE, VORATIQ_ENVIRONMENT_FILE, VORATIQ_INTERACTIVE_DIR, VORATIQ_INTERACTIVE_FILE, VORATIQ_INTERACTIVE_SESSIONS_DIR, VORATIQ_MESSAGE_DIR, VORATIQ_MESSAGE_FILE, VORATIQ_MESSAGE_SESSIONS_DIR, VORATIQ_ORCHESTRATION_FILE, VORATIQ_REDUCTION_DIR, VORATIQ_REDUCTION_FILE, VORATIQ_REDUCTION_SESSIONS_DIR, VORATIQ_RUN_DIR, VORATIQ_RUN_FILE, VORATIQ_RUN_SESSIONS_DIR, VORATIQ_SANDBOX_FILE, VORATIQ_SPEC_DIR, VORATIQ_SPEC_FILE, VORATIQ_SPEC_SESSIONS_DIR, VORATIQ_VERIFICATION_CONFIG_FILE, VORATIQ_VERIFICATION_DIR, VORATIQ_VERIFICATION_FILE, VORATIQ_VERIFICATION_SESSIONS_DIR, VORATIQ_VERIFICATION_TEMPLATES_DIR, } from "./structure.js";
+import { updateManagedState } from "./managed-state.js";
+import { resolveWorkspacePath, VORATIQ_AGENTS_FILE, VORATIQ_ENVIRONMENT_FILE, VORATIQ_INTERACTIVE_DIR, VORATIQ_INTERACTIVE_FILE, VORATIQ_INTERACTIVE_SESSIONS_DIR, VORATIQ_MANAGED_STATE_FILE, VORATIQ_MESSAGE_DIR, VORATIQ_MESSAGE_FILE, VORATIQ_MESSAGE_SESSIONS_DIR, VORATIQ_ORCHESTRATION_FILE, VORATIQ_REDUCTION_DIR, VORATIQ_REDUCTION_FILE, VORATIQ_REDUCTION_SESSIONS_DIR, VORATIQ_RUN_DIR, VORATIQ_RUN_FILE, VORATIQ_RUN_SESSIONS_DIR, VORATIQ_SANDBOX_FILE, VORATIQ_SPEC_DIR, VORATIQ_SPEC_FILE, VORATIQ_SPEC_SESSIONS_DIR, VORATIQ_VERIFICATION_CONFIG_FILE, VORATIQ_VERIFICATION_DIR, VORATIQ_VERIFICATION_FILE, VORATIQ_VERIFICATION_SESSIONS_DIR, VORATIQ_VERIFICATION_TEMPLATES_DIR, } from "./structure.js";
 import { buildDefaultAgentsTemplate, buildDefaultEnvironmentTemplate, buildDefaultSandboxTemplate, } from "./templates.js";
 import { buildDefaultVerificationConfigYaml, SHIPPED_VERIFICATION_TEMPLATES, } from "./verification-defaults.js";
 async function seedVerificationSurface(root, options = {}) {
@@ -99,6 +100,12 @@ const WORKSPACE_CONFIG_SEGMENTS = [
     VORATIQ_SANDBOX_FILE,
     VORATIQ_ORCHESTRATION_FILE,
 ];
+const VOLATILE_WORKSPACE_EXCLUDE_PATTERNS = [
+    "/.voratiq/*/index.json",
+    "/.voratiq/*/sessions/",
+    "/.voratiq/*/history.lock",
+];
+const VOLATILE_WORKSPACE_EXCLUDE_HEADER = "# voratiq runtime state (auto-managed)";
 export async function createWorkspace(root) {
     const createdDirectories = [];
     const createdFiles = [];
@@ -109,6 +116,7 @@ export async function createWorkspace(root) {
     const sandboxConfigPath = resolveWorkspacePath(root, VORATIQ_SANDBOX_FILE);
     const orchestrationConfigPath = resolveWorkspacePath(root, VORATIQ_ORCHESTRATION_FILE);
     const verificationConfigPath = resolveWorkspacePath(root, VORATIQ_VERIFICATION_CONFIG_FILE);
+    const managedStatePath = resolveWorkspacePath(root, VORATIQ_MANAGED_STATE_FILE);
     const workspaceExists = await pathExists(workspaceDir);
     const [agentsConfigExists, environmentConfigExists] = await Promise.all([
         pathExists(agentsConfigPath),
@@ -123,6 +131,7 @@ export async function createWorkspace(root) {
         await mkdir(workspaceDir, { recursive: true });
         createdDirectories.push(relativeToRoot(root, workspaceDir));
     }
+    await ensureWorkspaceGitExclude(root);
     for (const domain of domainStructures) {
         if (!(await pathExists(domain.directoryPath))) {
             await mkdir(domain.directoryPath, { recursive: true });
@@ -165,6 +174,20 @@ export async function createWorkspace(root) {
         });
         createdFiles.push(relativeToRoot(root, orchestrationConfigPath));
     }
+    if (!agentsConfigExists || !orchestrationConfigExists) {
+        const [agentsContent, orchestrationContent] = await Promise.all([
+            readFile(agentsConfigPath, "utf8"),
+            readFile(orchestrationConfigPath, "utf8"),
+        ]);
+        const managedStateResult = await updateManagedState(root, {
+            agentsContent,
+            orchestrationContent,
+            orchestrationPreset: "pro",
+        });
+        if (managedStateResult.created) {
+            createdFiles.push(relativeToRoot(root, managedStatePath));
+        }
+    }
     const seededVerification = await seedVerificationSurface(root, {
         verificationConfigPath,
         configExists: verificationExists,
@@ -178,6 +201,7 @@ export async function repairWorkspaceStructure(root, options = {}) {
     const createdFiles = [];
     const workspaceDir = resolveWorkspacePath(root);
     await ensureWorkspaceDirectoryEntry(root, workspaceDir);
+    await ensureWorkspaceGitExclude(root);
     // Additive repair must not mutate config semantics.
     for (const configPath of resolveWorkspaceConfigPaths(root)) {
         const kind = await detectPathKind(configPath);
@@ -359,6 +383,46 @@ async function detectPathKind(path) {
     }
     return "other";
 }
+async function ensureWorkspaceGitExclude(root) {
+    const excludePath = await resolveGitExcludePath(root);
+    if (!excludePath) {
+        return;
+    }
+    const existing = (await pathExists(excludePath))
+        ? await readFile(excludePath, "utf8")
+        : "";
+    const lines = existing.split(/\r?\n/u);
+    const missingPatterns = VOLATILE_WORKSPACE_EXCLUDE_PATTERNS.filter((pattern) => !lines.includes(pattern));
+    if (missingPatterns.length === 0) {
+        return;
+    }
+    const nextLines = existing.length > 0 && !existing.endsWith("\n")
+        ? [...lines, VOLATILE_WORKSPACE_EXCLUDE_HEADER, ...missingPatterns]
+        : [
+            ...lines.filter((line, index, all) => !(index === all.length - 1 && line === "")),
+            VOLATILE_WORKSPACE_EXCLUDE_HEADER,
+            ...missingPatterns,
+        ];
+    await mkdir(dirname(excludePath), { recursive: true });
+    await writeFile(excludePath, `${nextLines.join("\n")}\n`, "utf8");
+}
+async function resolveGitExcludePath(root) {
+    const gitEntryPath = join(root, ".git");
+    const kind = await detectPathKind(gitEntryPath);
+    if (kind === "directory") {
+        return join(gitEntryPath, "info", "exclude");
+    }
+    if (kind !== "file") {
+        return undefined;
+    }
+    const raw = await readFile(gitEntryPath, "utf8");
+    const match = raw.match(/^gitdir:\s*(.+)\s*$/mu);
+    if (!match) {
+        return undefined;
+    }
+    const gitDir = resolveAbsolute(root, match[1]);
+    return join(gitDir, "info", "exclude");
+}
 async function validateWorkspaceIndexFile(root, domain) {
     const displayPath = relativeToRoot(root, domain.indexPath);
     let raw;

package/dist/workspace/shim.d.ts

@@ -1,3 +1,4 @@
+export declare const WORKSPACE_SHIM_RELATIVE_PATH: readonly ["dist", "commands", "run", "shim", "run-agent-shim.mjs"];
 export declare function ensureWorkspaceShim(options: {
     workspacePath: string;
     cliInstallRoot?: string;

package/dist/workspace/shim.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 import { isFileSystemError } from "../utils/fs.js";
 import { resolvePath } from "../utils/path.js";
 import { WorkspaceSetupError } from "./errors.js";
-const SHIM_RELATIVE_PATH = [
+export const WORKSPACE_SHIM_RELATIVE_PATH = [
     "dist",
     "commands",
     "run",
@@ -16,8 +16,8 @@ function resolveCliInstallRoot() {
 }
 export async function ensureWorkspaceShim(options) {
     const { workspacePath, cliInstallRoot = resolveCliInstallRoot() } = options;
-    const sourcePath = resolvePath(cliInstallRoot, ...SHIM_RELATIVE_PATH);
-    const targetPath = resolvePath(workspacePath, ...SHIM_RELATIVE_PATH);
+    const sourcePath = resolvePath(cliInstallRoot, ...WORKSPACE_SHIM_RELATIVE_PATH);
+    const targetPath = resolvePath(workspacePath, ...WORKSPACE_SHIM_RELATIVE_PATH);
     try {
         await access(sourcePath);
         await mkdir(dirname(targetPath), { recursive: true });

package/dist/workspace/structure.d.ts

@@ -27,6 +27,7 @@ export declare const VORATIQ_VERIFICATION_CONFIG_FILE = "verification.yaml";
 export declare const VORATIQ_ENVIRONMENT_FILE = "environment.yaml";
 export declare const VORATIQ_SANDBOX_FILE = "sandbox.yaml";
 export declare const VORATIQ_ORCHESTRATION_FILE = "orchestration.yaml";
+export declare const VORATIQ_MANAGED_STATE_FILE = "managed-state.json";
 export declare const WORKSPACE_DIRNAME = "workspace";
 export declare const CONTEXT_DIRNAME = "context";
 export declare const STDOUT_FILENAME = "stdout.log";

package/dist/workspace/structure.js

@@ -28,6 +28,7 @@ export const VORATIQ_VERIFICATION_CONFIG_FILE = "verification.yaml";
 export const VORATIQ_ENVIRONMENT_FILE = "environment.yaml";
 export const VORATIQ_SANDBOX_FILE = "sandbox.yaml";
 export const VORATIQ_ORCHESTRATION_FILE = "orchestration.yaml";
+export const VORATIQ_MANAGED_STATE_FILE = "managed-state.json";
 export const WORKSPACE_DIRNAME = "workspace";
 export const CONTEXT_DIRNAME = "context";
 export const STDOUT_FILENAME = "stdout.log";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "voratiq",
-  "version": "0.1.0-beta.21",
-  "description": "Agent ensembles to design, generate, and select the best code for every task.",
+  "version": "0.1.0-beta.22",
+  "description": "Run workflows, delegate to swarms, and verify outputs before you apply them.",
   "keywords": [
     "agent-ensembles",
     "agent-orchestration",

package/dist/cli/init.d.ts

@@ -1,15 +0,0 @@
-import { Command } from "commander";
-import type { InitCommandResult } from "../commands/init/types.js";
-import type { AgentPreset } from "../workspace/templates.js";
-import { type CommandOutputWriter } from "./output.js";
-export interface RunInitCommandResult extends InitCommandResult {
-    body: string;
-}
-export interface InitCommandOptions {
-    yes?: boolean;
-    preset?: AgentPreset;
-    presetProvided?: boolean;
-    writeOutput?: CommandOutputWriter;
-}
-export declare function runInitCommand(options?: InitCommandOptions): Promise<RunInitCommandResult>;
-export declare function createInitCommand(): Command;