astrocode-workflow 0.4.0 → 0.4.2

package/dist/src/tools/index.js

@@ -0,0 +1,94 @@
+import { createAstroInitTool } from "./init";
+import { createAstroStatusTool } from "./status";
+import { createAstroStoryQueueTool, createAstroStoryApproveTool, createAstroStoryBoardTool, createAstroStorySetStateTool } from "./story";
+import { createAstroSpecGetTool, createAstroSpecSetTool } from "./spec";
+import { createAstroRunGetTool, createAstroRunAbortTool } from "./run";
+import { createAstroWorkflowProceedTool } from "./workflow";
+import { createAstroStageStartTool, createAstroStageCompleteTool, createAstroStageFailTool, createAstroStageResetTool } from "./stage";
+import { createAstroArtifactPutTool, createAstroArtifactListTool, createAstroArtifactGetTool } from "./artifacts";
+import { createAstroInjectPutTool, createAstroInjectListTool, createAstroInjectSearchTool, createAstroInjectGetTool, createAstroInjectEligibleTool, createAstroInjectDebugDueTool } from "./injects";
+import { createAstroRepairTool } from "./repair";
+import { createAstroHealthTool } from "./health";
+import { createAstroResetTool } from "./reset";
+import { createAstroMetricsTool } from "./metrics";
+export function createAstroTools(opts) {
+    const { ctx, config, agents, runtime } = opts;
+    const { db } = runtime;
+    const hasDatabase = db !== null; // Source of truth: DB availability
+    const tools = {};
+    // Always available tools (work without database - guaranteed DB-independent)
+    tools.astro_status = createAstroStatusTool({ ctx, config });
+    tools.astro_spec_get = createAstroSpecGetTool({ ctx, config });
+    tools.astro_health = createAstroHealthTool({ ctx, config, db });
+    tools.astro_reset = createAstroResetTool({ ctx, config, db });
+    tools.astro_metrics = createAstroMetricsTool({ ctx, config });
+    // Recovery tool - available even in limited mode to allow DB initialization
+    tools.astro_init = createAstroInitTool({ ctx, config, runtime });
+    // Database-dependent tools
+    if (hasDatabase) {
+        // Ensure agents are available for workflow tools that require them
+        if (!agents) {
+            throw new Error("astro_workflow_proceed requires agents to be provided in normal mode.");
+        }
+        tools.astro_story_queue = createAstroStoryQueueTool({ ctx, config, db });
+        tools.astro_story_approve = createAstroStoryApproveTool({ ctx, config, db });
+        tools.astro_story_board = createAstroStoryBoardTool({ ctx, config, db });
+        tools.astro_story_set_state = createAstroStorySetStateTool({ ctx, config, db });
+        tools.astro_spec_set = createAstroSpecSetTool({ ctx, config, db });
+        tools.astro_run_get = createAstroRunGetTool({ ctx, config, db });
+        tools.astro_run_abort = createAstroRunAbortTool({ ctx, config, db });
+        tools.astro_workflow_proceed = createAstroWorkflowProceedTool({ ctx, config, db, agents });
+        tools.astro_stage_start = createAstroStageStartTool({ ctx, config, db });
+        tools.astro_stage_complete = createAstroStageCompleteTool({ ctx, config, db });
+        tools.astro_stage_fail = createAstroStageFailTool({ ctx, config, db });
+        tools.astro_stage_reset = createAstroStageResetTool({ ctx, config, db });
+        tools.astro_artifact_put = createAstroArtifactPutTool({ ctx, config, db });
+        tools.astro_artifact_list = createAstroArtifactListTool({ ctx, config, db });
+        tools.astro_artifact_get = createAstroArtifactGetTool({ ctx, config, db });
+        tools.astro_inject_put = createAstroInjectPutTool({ ctx, config, db });
+        tools.astro_inject_list = createAstroInjectListTool({ ctx, config, db });
+        tools.astro_inject_search = createAstroInjectSearchTool({ ctx, config, db });
+        tools.astro_inject_get = createAstroInjectGetTool({ ctx, config, db });
+        tools.astro_inject_eligible = createAstroInjectEligibleTool({ ctx, config, db });
+        tools.astro_inject_debug_due = createAstroInjectDebugDueTool({ ctx, config, db });
+        tools.astro_repair = createAstroRepairTool({ ctx, config, db });
+    }
+    // Create aliases for backward compatibility
+    const aliases = [
+        ["_astro_init", "astro_init"],
+        ["_astro_status", "astro_status"],
+        ["_astro_story_queue", "astro_story_queue"],
+        ["_astro_story_approve", "astro_story_approve"],
+        ["_astro_story_board", "astro_story_board"],
+        ["_astro_story_set_state", "astro_story_set_state"],
+        ["_astro_spec_get", "astro_spec_get"],
+        ["_astro_spec_set", "astro_spec_set"],
+        ["_astro_run_get", "astro_run_get"],
+        ["_astro_run_abort", "astro_run_abort"],
+        ["_astro_workflow_proceed", "astro_workflow_proceed"],
+        ["_astro_stage_start", "astro_stage_start"],
+        ["_astro_stage_complete", "astro_stage_complete"],
+        ["_astro_stage_fail", "astro_stage_fail"],
+        ["_astro_stage_reset", "astro_stage_reset"],
+        ["_astro_artifact_put", "astro_artifact_put"],
+        ["_astro_artifact_list", "astro_artifact_list"],
+        ["_astro_artifact_get", "astro_artifact_get"],
+        ["_astro_inject_put", "astro_inject_put"],
+        ["_astro_inject_list", "astro_inject_list"],
+        ["_astro_inject_search", "astro_inject_search"],
+        ["_astro_inject_get", "astro_inject_get"],
+        ["_astro_inject_eligible", "astro_inject_eligible"],
+        ["_astro_inject_debug_due", "astro_inject_debug_due"],
+        ["_astro_repair", "astro_repair"],
+        ["_astro_health", "astro_health"],
+        ["_astro_reset", "astro_reset"],
+        ["_astro_metrics", "astro_metrics"],
+    ];
+    // Only add aliases for tools that exist
+    for (const [alias, target] of aliases) {
+        if (tools[target]) {
+            tools[alias] = tools[target];
+        }
+    }
+    return tools;
+}

package/dist/src/tools/init.d.ts

@@ -0,0 +1,17 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+type RuntimeState = {
+    db: SqliteDb | null;
+    limitedMode: boolean;
+    limitedModeReason: null | {
+        code: "db_init_failed" | "schema_too_old" | "schema_downgrade" | "schema_migration_failed";
+        details: any;
+    };
+};
+export declare function createAstroInitTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    runtime: RuntimeState;
+}): ToolDefinition;
+export {};

package/dist/src/tools/init.js

@@ -0,0 +1,96 @@
+import fs from "node:fs";
+import path from "node:path";
+import { tool } from "@opencode-ai/plugin/tool";
+import { ensureSchema, openSqlite, configurePragmas } from "../state/db";
+import { getAstroPaths, ensureAstroDirs } from "../shared/paths";
+import { nowISO } from "../shared/time";
+import { sha256Hex } from "../shared/hash";
+export function createAstroInitTool(opts) {
+    const { ctx, config, runtime } = opts;
+    return tool({
+        description: "Initialize Astrocode vNext in this repo: create .astro directories, ensure SQLite schema, and create a placeholder spec if missing. Idempotent.",
+        args: {
+            ensure_spec: tool.schema.boolean().default(true),
+            spec_placeholder: tool.schema.string().default("# Project Spec\n\n(Write the spec here.)\n"),
+        },
+        execute: async ({ ensure_spec, spec_placeholder }) => {
+            const repoRoot = ctx.directory;
+            const paths = getAstroPaths(repoRoot, config.db.path);
+            ensureAstroDirs(paths);
+            const hadDbAlready = !!runtime.db;
+            let db = runtime.db;
+            let publishedToRuntime = false;
+            try {
+                if (!db) {
+                    try {
+                        db = openSqlite(paths.dbPath, { busyTimeoutMs: config.db.busy_timeout_ms });
+                        configurePragmas(db, config.db.pragmas);
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        throw new Error(`❌ Failed to open database at ${paths.dbPath}: ${msg}. Install a SQLite driver (better-sqlite3/bun:sqlite) and check file permissions.`);
+                    }
+                }
+                // Source-of-truth for schema + repo_state invariants.
+                ensureSchema(db, { allowAutoMigrate: config.db.allow_auto_migrate });
+                // Postcondition: repo_state must exist after ensureSchema.
+                try {
+                    db.prepare("SELECT schema_version FROM repo_state WHERE id = 1").get();
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    throw new Error(`❌ Schema initialization incomplete: repo_state missing/unreadable after ensureSchema (${msg})`);
+                }
+                if (ensure_spec) {
+                    if (!fs.existsSync(paths.specPath)) {
+                        fs.writeFileSync(paths.specPath, spec_placeholder);
+                    }
+                    const content = fs.readFileSync(paths.specPath, "utf8");
+                    const specHash = sha256Hex(content);
+                    const now = nowISO();
+                    // Update hash; fail with a clear error if schema is mismatched.
+                    try {
+                        db.prepare(`
+              UPDATE repo_state
+              SET spec_hash_after = ?, updated_at = ?
+              WHERE id = 1
+            `).run(specHash, now);
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        throw new Error(`❌ Failed to update repo_state spec hash (schema mismatch?): ${msg}`);
+                    }
+                }
+                // Best-effort: if we recovered DB in-process, publish it so the harness can use it immediately.
+                // (If your harness reads runtime at creation-time only, this still helps future tool calls.)
+                if (!hadDbAlready && db) {
+                    runtime.db = db;
+                    runtime.limitedMode = false;
+                    runtime.limitedModeReason = null;
+                    publishedToRuntime = true;
+                }
+                const stat = db.prepare("SELECT schema_version, created_at, updated_at FROM repo_state WHERE id=1").get();
+                return [
+                    `✅ Astrocode initialized.`,
+                    ``,
+                    `- Repo: ${repoRoot}`,
+                    `- DB: ${path.relative(repoRoot, paths.dbPath)} (schema_version=${stat?.schema_version ?? "?"})`,
+                    `- Spec: ${path.relative(repoRoot, paths.specPath)}`,
+                    ``,
+                    publishedToRuntime
+                        ? `Next: run /astro-status. (DB recovered in-process.)`
+                        : `Next: restart the agent/runtime if Astrocode is still in Limited Mode, then run /astro-status.`,
+                ].join("\n");
+            }
+            finally {
+                // Only close if this tool opened it AND we did not publish it for ongoing use.
+                if (!hadDbAlready && !publishedToRuntime && db && typeof db.close === "function") {
+                    try {
+                        db.close();
+                    }
+                    catch { }
+                }
+            }
+        },
+    });
+}

package/dist/src/tools/injects.d.ts

@@ -0,0 +1,53 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+export declare function createAstroInjectPutTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;
+export declare function createAstroInjectListTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;
+export declare function createAstroInjectGetTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;
+export declare function createAstroInjectSearchTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;
+export type InjectRow = {
+    inject_id: string;
+    type: string;
+    title: string;
+    body_md: string;
+    tags_json: string;
+    scope: string;
+    source: string;
+    priority: number;
+    expires_at: string | null;
+    sha256: string;
+    created_at: string;
+    updated_at: string;
+};
+export declare function selectEligibleInjects(db: SqliteDb, opts: {
+    nowIso: string;
+    scopeAllowlist: string[];
+    typeAllowlist: string[];
+    limit?: number;
+}): InjectRow[];
+export declare function createAstroInjectEligibleTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;
+export declare function createAstroInjectDebugDueTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;

package/dist/src/tools/injects.js

@@ -0,0 +1,325 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { withTx } from "../state/db";
+import { nowISO } from "../shared/time";
+import { sha256Hex } from "../shared/hash";
+const VALID_INJECT_TYPES = ["note", "policy", "reminder", "debug"];
+function validateInjectType(type) {
+    if (!VALID_INJECT_TYPES.includes(type)) {
+        throw new Error(`Invalid inject type "${type}". Must be one of: ${VALID_INJECT_TYPES.join(", ")}`);
+    }
+    return type;
+}
+function validateTimestamp(timestamp) {
+    if (!timestamp)
+        return null;
+    // Strict ISO 8601 UTC with Z suffix, sortable as string.
+    const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/;
+    if (!isoRegex.test(timestamp)) {
+        throw new Error(`Invalid timestamp format. Expected ISO 8601 UTC with Z suffix (e.g., "2026-01-23T13:05:19.000Z"), got: "${timestamp}"`);
+    }
+    const parsed = Date.parse(timestamp);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`Invalid timestamp: "${timestamp}" does not represent a valid date`);
+    }
+    return timestamp;
+}
+function parseJsonStringArray(name, raw) {
+    let v;
+    try {
+        v = JSON.parse(raw);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`${name} must be valid JSON. Parse error: ${msg}`);
+    }
+    if (!Array.isArray(v) || !v.every((x) => typeof x === "string")) {
+        throw new Error(`${name} must be a JSON array of strings`);
+    }
+    return v;
+}
+function newInjectId() {
+    return `inj_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+export function createAstroInjectPutTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Create/update an inject (note/policy) stored in the DB. Useful for persistent rules.",
+        args: {
+            inject_id: tool.schema.string().optional(),
+            type: tool.schema.string().default("note"),
+            title: tool.schema.string().min(1),
+            body_md: tool.schema.string().min(1),
+            tags_json: tool.schema.string().default("[]"),
+            scope: tool.schema.string().default("repo"),
+            source: tool.schema.string().default("user"),
+            priority: tool.schema.number().int().default(50),
+            expires_at: tool.schema.string().nullable().optional(),
+        },
+        execute: async ({ inject_id, type, title, body_md, tags_json, scope, source, priority, expires_at }) => {
+            const id = inject_id ?? newInjectId();
+            const now = nowISO();
+            const sha = sha256Hex(body_md);
+            const validatedType = validateInjectType(type);
+            const validatedExpiresAt = validateTimestamp(expires_at);
+            // Ensure tags_json is at least valid JSON (we do not enforce schema here beyond validity).
+            try {
+                JSON.parse(tags_json);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                throw new Error(`tags_json must be valid JSON. Parse error: ${msg}`);
+            }
+            return withTx(db, () => {
+                const existing = db.prepare("SELECT inject_id FROM injects WHERE inject_id=?").get(id);
+                if (existing) {
+                    db.prepare(`
+            INSERT INTO injects (
+              inject_id,
+              type,
+              title,
+              body_md,
+              tags_json,
+              scope,
+              source,
+              priority,
+              expires_at,
+              sha256,
+              created_at,
+              updated_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(inject_id) DO UPDATE SET
+              type=excluded.type,
+              title=excluded.title,
+              body_md=excluded.body_md,
+              tags_json=excluded.tags_json,
+              scope=excluded.scope,
+              source=excluded.source,
+              priority=excluded.priority,
+              expires_at=excluded.expires_at,
+              sha256=excluded.sha256,
+              updated_at=excluded.updated_at
+          `).run(id, validatedType, title, body_md, tags_json, scope, source, priority, validatedExpiresAt, sha, now, now);
+                    return `✅ Updated inject ${id}: ${title}`;
+                }
+                db.prepare("INSERT INTO injects (inject_id, type, title, body_md, tags_json, scope, source, priority, expires_at, sha256, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(id, validatedType, title, body_md, tags_json, scope, source, priority, validatedExpiresAt, sha, now, now);
+                return `✅ Created inject ${id}: ${title}`;
+            });
+        },
+    });
+}
+export function createAstroInjectListTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "List injects (optionally filtered by scope/type).",
+        args: {
+            scope: tool.schema.string().optional(),
+            type: tool.schema.string().optional(),
+            limit: tool.schema.number().int().positive().default(50),
+        },
+        execute: async ({ scope, type, limit }) => {
+            const where = [];
+            const params = [];
+            if (scope) {
+                where.push("scope = ?");
+                params.push(scope);
+            }
+            if (type) {
+                // Keep list tool permissive (debugging), but still prevents obvious garbage if used.
+                validateInjectType(type);
+                where.push("type = ?");
+                params.push(type);
+            }
+            const sql = `
+        SELECT inject_id, type, title, scope, priority, created_at, updated_at
+        FROM injects
+        ${where.length ? "WHERE " + where.join(" AND ") : ""}
+        ORDER BY priority DESC, updated_at DESC
+        LIMIT ?
+      `;
+            const rows = db.prepare(sql).all(...params, limit);
+            return JSON.stringify(rows, null, 2);
+        },
+    });
+}
+export function createAstroInjectGetTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Get an inject by id (full body).",
+        args: {
+            inject_id: tool.schema.string().min(1),
+        },
+        execute: async ({ inject_id }) => {
+            const row = db.prepare("SELECT * FROM injects WHERE inject_id=?").get(inject_id);
+            if (!row)
+                throw new Error(`Inject not found: ${inject_id}`);
+            return JSON.stringify(row, null, 2);
+        },
+    });
+}
+export function createAstroInjectSearchTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Search injects by query substring over title/body/tags. Returns matches ordered by priority/recency.",
+        args: {
+            q: tool.schema.string().min(1),
+            scope: tool.schema.string().optional(),
+            limit: tool.schema.number().int().positive().default(20),
+        },
+        execute: async ({ q, scope, limit }) => {
+            const like = `%${q}%`;
+            const where = ["(title LIKE ? OR body_md LIKE ? OR tags_json LIKE ?)"];
+            const params = [like, like, like];
+            if (scope) {
+                where.push("scope = ?");
+                params.push(scope);
+            }
+            const sql = `
+        SELECT inject_id, type, title, scope, priority, updated_at
+        FROM injects
+        WHERE ${where.join(" AND ")}
+        ORDER BY priority DESC, updated_at DESC
+        LIMIT ?
+      `;
+            const rows = db.prepare(sql).all(...params, limit);
+            return JSON.stringify(rows, null, 2);
+        },
+    });
+}
+export function selectEligibleInjects(db, opts) {
+    const { nowIso, scopeAllowlist, typeAllowlist, limit = 50 } = opts;
+    if (!Array.isArray(scopeAllowlist) || scopeAllowlist.length === 0) {
+        throw new Error("selectEligibleInjects: scopeAllowlist must be a non-empty array");
+    }
+    if (!Array.isArray(typeAllowlist) || typeAllowlist.length === 0) {
+        throw new Error("selectEligibleInjects: typeAllowlist must be a non-empty array");
+    }
+    // Build placeholders safely (guaranteed non-empty).
+    const scopeQs = scopeAllowlist.map(() => "?").join(", ");
+    const typeQs = typeAllowlist.map(() => "?").join(", ");
+    const sql = `
+    SELECT *
+    FROM injects
+    WHERE (expires_at IS NULL OR expires_at > ?)
+      AND scope IN (${scopeQs})
+      AND type IN (${typeQs})
+    ORDER BY priority DESC, updated_at DESC
+    LIMIT ?
+  `;
+    const params = [nowIso, ...scopeAllowlist, ...typeAllowlist, limit];
+    return db.prepare(sql).all(...params);
+}
+export function createAstroInjectEligibleTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Debug: show which injects are eligible right now for injection.",
+        args: {
+            scopes_json: tool.schema.string().default('["repo","global"]'),
+            types_json: tool.schema.string().default('["note","policy"]'),
+            limit: tool.schema.number().int().positive().default(50),
+        },
+        execute: async ({ scopes_json, types_json, limit }) => {
+            const now = nowISO();
+            const scopes = parseJsonStringArray("scopes_json", scopes_json);
+            const types = parseJsonStringArray("types_json", types_json);
+            // Validate types against the known set to keep selection sane.
+            for (const t of types)
+                validateInjectType(t);
+            const rows = selectEligibleInjects(db, {
+                nowIso: now,
+                scopeAllowlist: scopes,
+                typeAllowlist: types,
+                limit,
+            });
+            return JSON.stringify({ now, count: rows.length, rows }, null, 2);
+        },
+    });
+}
+export function createAstroInjectDebugDueTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Debug: show comprehensive injection diagnostics - why injects were selected/skipped.",
+        args: {
+            scopes_json: tool.schema.string().default('["repo","global"]'),
+            types_json: tool.schema.string().default('["note","policy"]'),
+        },
+        execute: async ({ scopes_json, types_json }) => {
+            const now = nowISO();
+            const nowMs = Date.parse(now);
+            const scopes = parseJsonStringArray("scopes_json", scopes_json);
+            const types = parseJsonStringArray("types_json", types_json);
+            for (const t of types)
+                validateInjectType(t);
+            const allInjects = db.prepare("SELECT * FROM injects").all();
+            let total = allInjects.length;
+            let selected = 0;
+            let skippedExpired = 0;
+            let skippedScope = 0;
+            let skippedType = 0;
+            let skippedUnparseableExpiresAt = 0;
+            const excludedReasons = [];
+            const selectedInjects = [];
+            for (const inject of allInjects) {
+                const reasons = [];
+                // Expiration: parse to ms for correctness across legacy rows.
+                if (inject.expires_at) {
+                    const expMs = Date.parse(String(inject.expires_at));
+                    if (!Number.isFinite(expMs)) {
+                        reasons.push("expires_at_unparseable");
+                        skippedUnparseableExpiresAt++;
+                    }
+                    else if (expMs <= nowMs) {
+                        reasons.push("expired");
+                        skippedExpired++;
+                    }
+                }
+                if (!scopes.includes(inject.scope)) {
+                    reasons.push("scope");
+                    skippedScope++;
+                }
+                if (!types.includes(inject.type)) {
+                    reasons.push("type");
+                    skippedType++;
+                }
+                if (reasons.length > 0) {
+                    excludedReasons.push({
+                        inject_id: inject.inject_id,
+                        title: inject.title,
+                        reasons,
+                        scope: inject.scope,
+                        type: inject.type,
+                        expires_at: inject.expires_at,
+                    });
+                }
+                else {
+                    selected++;
+                    selectedInjects.push({
+                        inject_id: inject.inject_id,
+                        title: inject.title,
+                        scope: inject.scope,
+                        type: inject.type,
+                        expires_at: inject.expires_at,
+                    });
+                }
+            }
+            return JSON.stringify({
+                now,
+                scopes_considered: scopes,
+                types_considered: types,
+                summary: {
+                    total_injects: total,
+                    selected_eligible: selected,
+                    excluded_total: total - selected,
+                    skipped_breakdown: {
+                        expired: skippedExpired,
+                        expires_at_unparseable: skippedUnparseableExpiresAt,
+                        scope: skippedScope,
+                        type: skippedType,
+                    },
+                },
+                selected_injects: selectedInjects,
+                excluded_injects: excludedReasons,
+            }, null, 2);
+        },
+    });
+}

package/dist/src/tools/lock.d.ts

@@ -0,0 +1,4 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+export declare function createAstroLockStatusTool(opts: {
+    ctx: any;
+}): ToolDefinition;

package/dist/src/tools/lock.js

@@ -0,0 +1,78 @@
+import path from "node:path";
+import { tool } from "@opencode-ai/plugin/tool";
+import { getLockStatus, tryRemoveStaleLock } from "../state/repo-lock";
+export function createAstroLockStatusTool(opts) {
+    const { ctx } = opts;
+    return tool({
+        description: "Check Astrocode lock status and attempt repair. Shows diagnostics (PID, age, session) and can remove stale/dead locks.",
+        args: {
+            attempt_repair: tool.schema.boolean().default(false).describe("If true, attempt to remove stale or dead locks"),
+        },
+        execute: async ({ attempt_repair }) => {
+            const repoRoot = ctx.directory;
+            const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+            const status = getLockStatus(lockPath);
+            if (!status.exists) {
+                return "✅ No lock file found. Repository is unlocked.";
+            }
+            const lines = [];
+            lines.push("# Astrocode Lock Status");
+            lines.push("");
+            lines.push("## Lock Details");
+            lines.push(`- **Path**: ${status.path}`);
+            lines.push(`- **PID**: ${status.pid} (${status.pidAlive ? '🟢 ALIVE' : '🔴 DEAD'})`);
+            lines.push(`- **Age**: ${status.ageMs ? Math.floor(status.ageMs / 1000) : '?'}s`);
+            lines.push(`- **Status**: ${status.isStale ? '⚠️ STALE' : '✅ FRESH'}`);
+            if (status.sessionId)
+                lines.push(`- **Session**: ${status.sessionId}`);
+            if (status.owner)
+                lines.push(`- **Owner**: ${status.owner}`);
+            if (status.instanceId)
+                lines.push(`- **Instance**: ${status.instanceId.substring(0, 8)}...`);
+            if (status.leaseId)
+                lines.push(`- **Lease**: ${status.leaseId.substring(0, 8)}...`);
+            if (status.createdAt)
+                lines.push(`- **Created**: ${status.createdAt}`);
+            if (status.updatedAt)
+                lines.push(`- **Updated**: ${status.updatedAt}`);
+            if (status.repoRoot)
+                lines.push(`- **Repo**: ${status.repoRoot}`);
+            lines.push(`- **Version**: ${status.version ?? 'unknown'}`);
+            lines.push("");
+            if (attempt_repair) {
+                lines.push("## Repair Attempt");
+                const result = tryRemoveStaleLock(lockPath);
+                if (result.removed) {
+                    lines.push(`✅ **Lock removed**: ${result.reason}`);
+                    lines.push("");
+                    lines.push("The repository is now unlocked and ready for use.");
+                }
+                else {
+                    lines.push(`⚠️ **Lock NOT removed**: ${result.reason}`);
+                    lines.push("");
+                    lines.push("**Recommendations**:");
+                    lines.push("- If the owning process has crashed, wait 30 seconds for automatic stale detection");
+                    lines.push("- If the process is still running, wait for it to complete");
+                    lines.push("- As a last resort, manually stop the process and run this tool again with attempt_repair=true");
+                }
+            }
+            else {
+                lines.push("## Recommendations");
+                if (!status.pidAlive) {
+                    lines.push("🔧 **Action Required**: Lock belongs to dead process. Run with `attempt_repair=true` to remove it.");
+                }
+                else if (status.isStale) {
+                    lines.push("🔧 **Action Suggested**: Lock is stale (not updated recently). Run with `attempt_repair=true` to remove it.");
+                }
+                else {
+                    lines.push("✅ Lock is active and healthy. The owning process is running normally.");
+                    lines.push("");
+                    lines.push("If you believe this is incorrect:");
+                    lines.push("- Wait 30 seconds and check again (automatic stale detection)");
+                    lines.push("- Run with `attempt_repair=true` only if you're certain the process has crashed");
+                }
+            }
+            return lines.join("\n");
+        },
+    });
+}