@feelingmindful/thinking-graph 1.10.1 → 1.11.0

package/dist/tools/execute-skills.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.js';
+import type { VaultBridge } from '../vault/bridge.js';
+export declare const executeSkillsSchema: z.ZodObject<{
+    executionId: z.ZodOptional<z.ZodString>;
+    planId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+    stepNumber: z.ZodNumber;
+    invocation: z.ZodString;
+    plugin: z.ZodString;
+    skill: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<["completed", "failed"]>>;
+    resultSummary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    decisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        content: string;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    techDebt: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        severity: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low"]>>;
+        effort: z.ZodOptional<z.ZodString>;
+        impact: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        metadata?: Record<string, unknown> | undefined;
+        severity?: "critical" | "high" | "medium" | "low" | undefined;
+        effort?: string | undefined;
+        impact?: string | undefined;
+    }, {
+        content: string;
+        metadata?: Record<string, unknown> | undefined;
+        severity?: "critical" | "high" | "medium" | "low" | undefined;
+        effort?: string | undefined;
+        impact?: string | undefined;
+    }>, "many">>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    invocation: string;
+    status: "completed" | "failed";
+    skill: string;
+    stepNumber: number;
+    plugin: string;
+    resultSummary: string;
+    sessionId?: string | undefined;
+    projectId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    purpose?: string | undefined;
+    planId?: string | undefined;
+    runId?: string | undefined;
+    executionId?: string | undefined;
+    decisions?: {
+        content: string;
+        metadata?: Record<string, unknown> | undefined;
+    }[] | undefined;
+    techDebt?: {
+        content: string;
+        metadata?: Record<string, unknown> | undefined;
+        severity?: "critical" | "high" | "medium" | "low" | undefined;
+        effort?: string | undefined;
+        impact?: string | undefined;
+    }[] | undefined;
+}, {
+    invocation: string;
+    skill: string;
+    stepNumber: number;
+    plugin: string;
+    resultSummary: string;
+    sessionId?: string | undefined;
+    projectId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    status?: "completed" | "failed" | undefined;
+    purpose?: string | undefined;
+    planId?: string | undefined;
+    runId?: string | undefined;
+    executionId?: string | undefined;
+    decisions?: {
+        content: string;
+        metadata?: Record<string, unknown> | undefined;
+    }[] | undefined;
+    techDebt?: {
+        content: string;
+        metadata?: Record<string, unknown> | undefined;
+        severity?: "critical" | "high" | "medium" | "low" | undefined;
+        effort?: string | undefined;
+        impact?: string | undefined;
+    }[] | undefined;
+}>;
+export type ExecuteSkillsInput = z.infer<typeof executeSkillsSchema>;
+export declare function executeSkillsHandler(graph: ThinkingGraph, input: ExecuteSkillsInput, vault?: VaultBridge, projectSlug?: string): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/execute-skills.js

@@ -0,0 +1,274 @@
+import { z } from 'zod';
+import { learnHandler } from './learn.js';
+import { findExecutionInstances, findStoredPlan, parseExecutionId, resolveExecutionInstance, resolveExecutionProgress, } from './execute-plan.js';
+const metadataSchema = z.record(z.unknown());
+const decisionOutputSchema = z.object({
+    content: z.string(),
+    metadata: metadataSchema.optional(),
+});
+const techDebtOutputSchema = z.object({
+    content: z.string(),
+    severity: z.enum(['critical', 'high', 'medium', 'low']).optional(),
+    effort: z.string().optional(),
+    impact: z.string().optional(),
+    metadata: metadataSchema.optional(),
+});
+export const executeSkillsSchema = z.object({
+    executionId: z.string().optional().describe('Execution ID returned by execute-plan for a specific run. Prefer passing this exact value forward once a run has started.'),
+    planId: z.string().optional().describe('Plan ID returned by plan-skills'),
+    runId: z.string().optional().describe('Execution instance ID for this plan within the project. Required to disambiguate when execute-plan returned availableRunIds.'),
+    stepNumber: z.coerce.number().int().min(1),
+    invocation: z.string(),
+    plugin: z.string(),
+    skill: z.string(),
+    purpose: z.string().optional(),
+    status: z.enum(['completed', 'failed']).default('completed'),
+    resultSummary: z.string().describe('Human-readable summary of what the step produced or why it failed'),
+    metadata: metadataSchema.optional(),
+    decisions: z.array(decisionOutputSchema).optional(),
+    techDebt: z.array(techDebtOutputSchema).optional(),
+    sessionId: z.string().optional(),
+    projectId: z.string().optional(),
+});
+function asRecord(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+async function resolveSession(graph, sessionId, projectId) {
+    if (!sessionId)
+        return graph.getCurrentSession();
+    return (await graph.storage.getSession(sessionId)) ?? graph.createSession({ id: sessionId, projectId });
+}
+function parseLearnResponse(result) {
+    return JSON.parse(result.content[0].text);
+}
+async function getPriorSkillResults(graph, _sessionId, projectId, executionId) {
+    const result = await graph.findNodes({ type: 'skill_result', projectId, limit: 1000 });
+    return result.items.filter(node => asRecord(node.metadata).executionId === executionId);
+}
+export async function executeSkillsHandler(graph, input, vault, projectSlug) {
+    const session = await resolveSession(graph, input.sessionId, input.projectId);
+    const parsedExecution = input.executionId ? parseExecutionId(input.executionId) : null;
+    const planId = input.planId ?? parsedExecution?.planId;
+    const status = input.status ?? 'completed';
+    if (input.executionId && !parsedExecution) {
+        return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'Invalid executionId format.' }) }] };
+    }
+    if (input.planId && parsedExecution && input.planId !== parsedExecution.planId) {
+        return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'planId does not match executionId.' }) }] };
+    }
+    if (input.runId && parsedExecution && input.runId !== parsedExecution.runId) {
+        return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'runId does not match executionId.' }) }] };
+    }
+    if (!planId) {
+        return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'executionId or planId is required. When multiple runs exist, pass runId from execute-plan.availableRunIds.' }) }] };
+    }
+    const storedPlan = await findStoredPlan(graph, session.id, input.projectId, planId);
+    if (!storedPlan) {
+        return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: `No stored plan found for ${planId}. Run execute-plan first.` }) }] };
+    }
+    let executionId = input.executionId;
+    let runId = input.runId ?? parsedExecution?.runId;
+    if (executionId) {
+        const knownInstances = await findExecutionInstances(graph, input.projectId, planId);
+        const matchingInstance = knownInstances.find(instance => instance.executionId === executionId);
+        if (!matchingInstance) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            status: 'error',
+                            planId,
+                            error: `Execution ${executionId} is unknown. Run execute-plan first for this run and reuse its executionId/runId pair.`,
+                            availableRunIds: knownInstances.map(instance => instance.runId).sort(),
+                        }),
+                    }],
+            };
+        }
+        runId = matchingInstance.runId;
+    }
+    else {
+        const executionInstance = await resolveExecutionInstance(graph, session, input.projectId, storedPlan, input.runId);
+        if (!executionInstance.instance) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            status: 'error',
+                            planId,
+                            error: executionInstance.error,
+                            availableRunIds: executionInstance.availableRunIds ?? [],
+                        }),
+                    }],
+            };
+        }
+        executionId = executionInstance.instance.executionId;
+        runId = executionInstance.instance.runId;
+    }
+    if (!runId) {
+        runId = parseExecutionId(executionId)?.runId;
+    }
+    const progress = await resolveExecutionProgress(graph, session.id, input.projectId, storedPlan, executionId);
+    if (!progress.nextStep) {
+        return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: `Execution ${executionId} is already complete.` }) }] };
+    }
+    if (progress.blockingGate) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        status: 'awaiting_approval',
+                        executionId,
+                        planId,
+                        runId,
+                        blockedByGate: progress.blockingGate,
+                        nextStep: progress.nextStep,
+                        error: `Approval gate ${progress.blockingGate.id} must be approved before step ${progress.nextStep.stepNumber}. Rerun execute-plan with runId ${runId}.`,
+                    }),
+                }],
+        };
+    }
+    if (progress.nextStep.stepNumber !== input.stepNumber) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        status: 'error',
+                        executionId,
+                        planId,
+                        runId,
+                        error: `Step ${input.stepNumber} is out of order. Record step ${progress.nextStep.stepNumber} next.`,
+                        nextStep: progress.nextStep,
+                        completedSteps: progress.completedSteps,
+                    }),
+                }],
+        };
+    }
+    if (input.invocation !== progress.nextStep.invocation
+        || input.plugin !== progress.nextStep.plugin
+        || input.skill !== progress.nextStep.skill) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        status: 'error',
+                        executionId,
+                        planId,
+                        runId,
+                        error: `Step ${input.stepNumber} does not match the stored plan entry.`,
+                        expectedStep: progress.nextStep,
+                    }),
+                }],
+        };
+    }
+    const priorResults = await getPriorSkillResults(graph, session.id, input.projectId, executionId);
+    const attempt = priorResults.filter(node => asRecord(node.metadata).stepNumber === input.stepNumber).length + 1;
+    const priorStepNode = priorResults
+        .filter(node => asRecord(node.metadata).stepNumber === input.stepNumber - 1)
+        .sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
+    const skillResult = await learnHandler(graph, {
+        content: `Step ${input.stepNumber} (${input.invocation}) attempt ${attempt}: ${input.resultSummary}`,
+        type: 'skill_result',
+        projectId: input.projectId,
+        sessionId: session.id,
+        metadata: {
+            kind: 'skill_execution',
+            executionId,
+            planId,
+            runId,
+            stepNumber: input.stepNumber,
+            invocation: input.invocation,
+            plugin: input.plugin,
+            skill: input.skill,
+            purpose: input.purpose,
+            status,
+            attempt,
+            ...(input.metadata ?? {}),
+        },
+    }, vault, projectSlug);
+    const skillResultData = parseLearnResponse(skillResult);
+    if (priorStepNode) {
+        await graph.addEdge({
+            sourceId: skillResultData.nodeId,
+            targetId: priorStepNode.id,
+            type: 'depends_on',
+            reasoning: 'Execution order dependency between consecutive steps.',
+        });
+    }
+    const decisionNodeIds = [];
+    for (const decision of input.decisions ?? []) {
+        const recorded = await learnHandler(graph, {
+            content: decision.content,
+            type: 'decision',
+            projectId: input.projectId,
+            sessionId: session.id,
+            metadata: {
+                kind: 'skill_output_decision',
+                executionId,
+                planId,
+                runId,
+                stepNumber: input.stepNumber,
+                invocation: input.invocation,
+                sourceSkillResultId: skillResultData.nodeId,
+                ...(decision.metadata ?? {}),
+            },
+        }, vault, projectSlug);
+        const recordedData = parseLearnResponse(recorded);
+        decisionNodeIds.push(recordedData.nodeId);
+        await graph.addEdge({
+            sourceId: recordedData.nodeId,
+            targetId: skillResultData.nodeId,
+            type: 'invoked_by',
+            reasoning: 'Decision captured from skill execution output.',
+        });
+    }
+    const techDebtNodeIds = [];
+    for (const debt of input.techDebt ?? []) {
+        const recorded = await learnHandler(graph, {
+            content: debt.content,
+            type: 'tech_debt',
+            projectId: input.projectId,
+            sessionId: session.id,
+            severity: debt.severity,
+            effort: debt.effort,
+            impact: debt.impact,
+            metadata: {
+                kind: 'skill_output_tech_debt',
+                executionId,
+                planId,
+                runId,
+                stepNumber: input.stepNumber,
+                invocation: input.invocation,
+                sourceSkillResultId: skillResultData.nodeId,
+                ...(debt.metadata ?? {}),
+            },
+        }, vault, projectSlug);
+        const recordedData = parseLearnResponse(recorded);
+        techDebtNodeIds.push(recordedData.nodeId);
+        await graph.addEdge({
+            sourceId: recordedData.nodeId,
+            targetId: skillResultData.nodeId,
+            type: 'invoked_by',
+            reasoning: 'Tech debt captured from skill execution output.',
+        });
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    status,
+                    executionId,
+                    planId,
+                    runId,
+                    skillResultNodeId: skillResultData.nodeId,
+                    stepNumber: input.stepNumber,
+                    attempt,
+                    decisionNodeIds,
+                    techDebtNodeIds,
+                    recordedCount: 1 + decisionNodeIds.length + techDebtNodeIds.length,
+                    nextAction: status === 'failed'
+                        ? `Fix or rerun ${input.invocation}, then record a successful retry before continuing.`
+                        : `Rerun execute-plan for ${executionId} to continue with the next step.`,
+                }),
+            }],
+    };
+}

package/dist/tools/learn.d.ts

@@ -5,6 +5,7 @@ export declare const learnSchema: z.ZodObject<{
     content: z.ZodString;
     type: z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>;
     projectId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
     filePath: z.ZodOptional<z.ZodString>;
     lineRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     severity: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low"]>>;
@@ -28,6 +29,7 @@ export declare const learnSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research";
     content: string;
+    sessionId?: string | undefined;
     projectId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
     severity?: "critical" | "high" | "medium" | "low" | undefined;
@@ -44,6 +46,7 @@ export declare const learnSchema: z.ZodObject<{
 }, {
     type: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research";
     content: string;
+    sessionId?: string | undefined;
     projectId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
     severity?: "critical" | "high" | "medium" | "low" | undefined;

package/dist/tools/learn.js

@@ -5,6 +5,7 @@ export const learnSchema = z.object({
     content: z.string().describe('What was learned'),
     type: z.enum(NODE_TYPES).describe('Node type'),
     projectId: z.string().optional(),
+    sessionId: z.string().optional(),
     filePath: z.string().optional().describe('For code_facts'),
     lineRange: z.tuple([z.coerce.number(), z.coerce.number()]).optional().describe('Line range [start, end]'),
     severity: z.enum(['critical', 'high', 'medium', 'low']).optional().describe('For tech_debt'),
@@ -46,7 +47,9 @@ export async function learnHandler(graph, input, vault, projectSlug) {
         metadata.effort = input.effort;
     if (input.impact)
         metadata.impact = input.impact;
-    const session = await graph.getCurrentSession();
+    const session = input.sessionId
+        ? ((await graph.storage.getSession(input.sessionId)) ?? await graph.createSession({ id: input.sessionId, projectId: input.projectId }))
+        : await graph.getCurrentSession();
     const node = await graph.addNode({
         type: input.type,
         content: input.content,

package/dist/tools/plan-skills.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.js';
+export declare const planSkillsSchema: z.ZodObject<{
+    request: z.ZodString;
+    platform: z.ZodOptional<z.ZodEnum<["ios", "android", "web", "all"]>>;
+    goalVerb: z.ZodOptional<z.ZodString>;
+    areas: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    currentState: z.ZodOptional<z.ZodEnum<["new", "existing", "unknown"]>>;
+    detectedNeeds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    selectedInvocation: z.ZodOptional<z.ZodString>;
+    requireApproval: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
+    maxCandidates: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    request: string;
+    areas?: string[] | undefined;
+    platform?: "all" | "web" | "ios" | "android" | undefined;
+    currentState?: "unknown" | "new" | "existing" | undefined;
+    goalVerb?: string | undefined;
+    detectedNeeds?: string[] | undefined;
+    maxCandidates?: number | undefined;
+    selectedInvocation?: string | undefined;
+    requireApproval?: boolean | undefined;
+}, {
+    request: string;
+    areas?: string[] | undefined;
+    platform?: "all" | "web" | "ios" | "android" | undefined;
+    currentState?: "unknown" | "new" | "existing" | undefined;
+    goalVerb?: string | undefined;
+    detectedNeeds?: string[] | undefined;
+    maxCandidates?: number | undefined;
+    selectedInvocation?: string | undefined;
+    requireApproval?: unknown;
+}>;
+export type PlanSkillsInput = z.infer<typeof planSkillsSchema>;
+export declare function planSkillsHandler(graph: ThinkingGraph, input: PlanSkillsInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/plan-skills.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { buildPlanId, buildSkillPlan } from './skill-routing.js';
+const coerceBool = z.preprocess((v) => (v === 'true' ? true : v === 'false' ? false : v), z.boolean());
+export const planSkillsSchema = z.object({
+    request: z.string().describe('Task or problem to convert into an ordered skill execution plan'),
+    platform: z.enum(['ios', 'android', 'web', 'all']).optional().describe('Preferred platform filter'),
+    goalVerb: z.string().optional().describe('Desired outcome verb such as audit, create, refactor, configure, research, or full'),
+    areas: z.array(z.string()).optional().describe('Explicit areas to weight such as accessibility, auth, observability, or copy'),
+    currentState: z.enum(['new', 'existing', 'unknown']).optional().describe('Whether the target is greenfield or an existing project'),
+    detectedNeeds: z.array(z.string()).optional().describe('Known states such as missing, needs-work, or good'),
+    selectedInvocation: z.string().optional().describe('Force a specific routed invocation when you want the plan built from a chosen candidate'),
+    requireApproval: coerceBool.optional().describe('Whether to insert approval gates before execution (default true)'),
+    maxCandidates: z.coerce.number().int().min(1).max(10).optional().describe('Maximum ranked candidates to consider during routing'),
+});
+export async function planSkillsHandler(graph, input) {
+    const planned = await buildSkillPlan(graph, input);
+    const planId = planned.plan.length > 0
+        ? buildPlanId({ request: input.request, plan: planned.plan, approvalGates: planned.approvalGates })
+        : null;
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    planId,
+                    request: input.request,
+                    desiredVerb: planned.desiredVerb,
+                    inferredAreas: planned.inferredAreas,
+                    heuristicNotes: planned.heuristicNotes,
+                    route: planned.route,
+                    plan: planned.plan,
+                    approvalGates: planned.approvalGates,
+                    fallbacks: planned.fallbacks,
+                    executionReady: planned.approvalGates.length === 0,
+                    nextAction: planned.approvalGates.length > 0
+                        ? `Request approval for ${planned.approvalGates[0].id} before executing step ${planned.approvalGates[0].beforeStepNumber}.`
+                        : 'Execution may proceed.',
+                }),
+            }],
+    };
+}

package/dist/tools/recommend-skills.js

@@ -60,8 +60,8 @@ export async function recommendSkillsHandler(graph, input) {
     // Build suggestions for the agent
     const suggestions = skills.slice(0, 3).map(s => ({
         tool: 'skill',
-        when: `Invoke ${s.plugin}:${s.skill} to ${s.verb ?? 'run'} ${s.areas.length > 0 ? `(covers: ${s.areas.join(', ')})` : ''}`,
-        example: { skill: `${s.plugin}:${s.skill}` },
+        when: `Run \`${s.invocation}\`${s.areas.length > 0 ? ` (covers: ${s.areas.join(', ')})` : ''}`,
+        example: { skill: `${s.plugin}:${s.skill}`, invocation: s.invocation },
     }));
     // If skills produce node types, suggest piping results back via learn
     if (skills.some(s => s.produces.length > 0)) {

package/dist/tools/route-skills.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.js';
+export declare const routeSkillsSchema: z.ZodObject<{
+    request: z.ZodString;
+    platform: z.ZodOptional<z.ZodEnum<["ios", "android", "web", "all"]>>;
+    goalVerb: z.ZodOptional<z.ZodString>;
+    areas: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    currentState: z.ZodOptional<z.ZodEnum<["new", "existing", "unknown"]>>;
+    detectedNeeds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    maxCandidates: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    request: string;
+    areas?: string[] | undefined;
+    platform?: "all" | "web" | "ios" | "android" | undefined;
+    currentState?: "unknown" | "new" | "existing" | undefined;
+    goalVerb?: string | undefined;
+    detectedNeeds?: string[] | undefined;
+    maxCandidates?: number | undefined;
+}, {
+    request: string;
+    areas?: string[] | undefined;
+    platform?: "all" | "web" | "ios" | "android" | undefined;
+    currentState?: "unknown" | "new" | "existing" | undefined;
+    goalVerb?: string | undefined;
+    detectedNeeds?: string[] | undefined;
+    maxCandidates?: number | undefined;
+}>;
+export type RouteSkillsInput = z.infer<typeof routeSkillsSchema>;
+export declare function routeSkillsHandler(graph: ThinkingGraph, input: RouteSkillsInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/route-skills.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { routeSkills } from './skill-routing.js';
+export const routeSkillsSchema = z.object({
+    request: z.string().describe('Task or problem to route to the best installed skill workflow'),
+    platform: z.enum(['ios', 'android', 'web', 'all']).optional().describe('Preferred platform filter'),
+    goalVerb: z.string().optional().describe('Desired outcome verb such as audit, create, refactor, configure, research, or full'),
+    areas: z.array(z.string()).optional().describe('Explicit areas to weight such as accessibility, auth, observability, or copy'),
+    currentState: z.enum(['new', 'existing', 'unknown']).optional().describe('Whether the target is greenfield or an existing project'),
+    detectedNeeds: z.array(z.string()).optional().describe('Known states such as missing, needs-work, or good'),
+    maxCandidates: z.coerce.number().int().min(1).max(10).optional().describe('Maximum ranked candidates to return'),
+});
+export async function routeSkillsHandler(graph, input) {
+    const routed = await routeSkills(graph, input);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    request: input.request,
+                    desiredVerb: routed.desiredVerb,
+                    inferredAreas: routed.inferredAreas,
+                    heuristicNotes: routed.heuristicNotes,
+                    candidates: routed.candidates,
+                }),
+            }],
+    };
+}

package/dist/tools/skill-routing.d.ts

@@ -0,0 +1,63 @@
+import type { ThinkingGraph } from '../engine/graph.js';
+export interface SkillRoutingInput {
+    request: string;
+    platform?: 'ios' | 'android' | 'web' | 'all';
+    goalVerb?: string;
+    areas?: string[];
+    currentState?: 'new' | 'existing' | 'unknown';
+    detectedNeeds?: string[];
+    maxCandidates?: number;
+    selectedInvocation?: string;
+}
+export interface RoutedSkillCandidate {
+    id: string;
+    plugin: string;
+    skill: string;
+    invocation: string;
+    verb?: string;
+    platform?: string;
+    areas: string[];
+    detects: string[];
+    produces: string[];
+    invokes: string[];
+    score: number;
+    reasons: string[];
+}
+export interface SkillPlanStep {
+    stepNumber: number;
+    invocation: string;
+    plugin: string;
+    skill: string;
+    verb?: string;
+    purpose: string;
+    approvalGateIds: string[];
+}
+export interface ApprovalGate {
+    id: string;
+    title: string;
+    beforeStepNumber: number;
+    reason: string;
+    prompt: string;
+}
+export declare function buildPlanId(input: {
+    request?: string;
+    plan: SkillPlanStep[];
+    approvalGates: ApprovalGate[];
+}): string;
+export declare function routeSkills(graph: ThinkingGraph, input: SkillRoutingInput): Promise<{
+    desiredVerb?: string;
+    inferredAreas: string[];
+    heuristicNotes: string[];
+    candidates: RoutedSkillCandidate[];
+}>;
+export declare function buildSkillPlan(graph: ThinkingGraph, input: SkillRoutingInput & {
+    requireApproval?: boolean;
+}): Promise<{
+    desiredVerb?: string;
+    inferredAreas: string[];
+    heuristicNotes: string[];
+    route: RoutedSkillCandidate | null;
+    plan: SkillPlanStep[];
+    approvalGates: ApprovalGate[];
+    fallbacks: RoutedSkillCandidate[];
+}>;