@gtrabanco/pi-agentic-workflow 0.1.0

package/dist/routing/state.js

@@ -0,0 +1,65 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { mkdirSync } from "node:fs";
+/**
+ * Global package state (SPEC S9, D-E7): the first-run hint acknowledgement.
+ *
+ * Deliberately a file of its own next to the config, never inside it — writing
+ * state must not rewrite configuration, and reading config must not depend on
+ * state. Every failure here is soft: a hint that cannot be persisted is shown
+ * again next session, which is a nuisance, not a broken command.
+ */
+const STATE_FILE_NAME = "pi-agentic-workflow-state.json";
+export const stateFilePath = (agentDir) => join(agentDir, STATE_FILE_NAME);
+const readOrNull = (path) => {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+};
+const writeThrough = (path, text) => {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, text);
+};
+export function createHintStore({ path, readFile = readOrNull, writeFile = writeThrough, }) {
+    let acknowledged = false;
+    const storedAcknowledged = () => {
+        const text = readFile(path);
+        if (text === null || text.trim() === "")
+            return false;
+        try {
+            const parsed = JSON.parse(text);
+            return typeof parsed === "object" && parsed !== null && typeof parsed.firstRunHintShownAt === "string";
+        }
+        catch {
+            // Corrupt state is treated as "never shown", so the operator sees the hint
+            // again rather than losing the only pointer to the settings command.
+            return false;
+        }
+    };
+    return {
+        pending() {
+            if (acknowledged)
+                return false;
+            if (storedAcknowledged()) {
+                acknowledged = true;
+                return false;
+            }
+            return true;
+        },
+        acknowledge(now = new Date().toISOString()) {
+            // Latch in memory first: a failing write must not re-show the hint on the
+            // next command in this same session.
+            acknowledged = true;
+            try {
+                writeFile(path, `${JSON.stringify({ firstRunHintShownAt: now }, null, 2)}\n`);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}

package/dist/routing/types.d.ts

@@ -0,0 +1,90 @@
+import type { ThinkingLevel } from "../config/types.js";
+/**
+ * The command-surface vocabulary (SPEC "Command surface (api)").
+ *
+ * Each type here is a NARROWER view of Pi's own API, declared structurally so
+ * the routing layer can be tested with plain objects instead of a live session.
+ * The one Pi type the router must never touch is the model: Pi's `Model` carries
+ * credentials and capability data the package has no business rebuilding, so the
+ * router holds it as an opaque `M` and only ever passes back what it received —
+ * which is why `setModel` needs no cast in the adapter.
+ */
+/** A routed slash command: the friendly name plus the canonical skill it runs. */
+export interface WorkflowCommand {
+    /** Slash name users type, without the leading slash. Equals the skill `name:`. */
+    name: string;
+    /** Bundled skill directory whose `SKILL.md` is expanded on dispatch. */
+    skill: string;
+    /** Frontmatter description, shown in Pi's command list. */
+    description?: string;
+}
+/** The identity of a model — all this package reads off Pi's `Model`. */
+export interface ModelRef {
+    provider: string;
+    id: string;
+}
+export declare const modelRefKey: (model: ModelRef) => string;
+/** Model availability: the two questions AC9 asks before a route is applied. */
+export interface ModelLookup<M extends ModelRef = ModelRef> {
+    find(provider: string, modelId: string): M | undefined;
+    hasConfiguredAuth(model: M): boolean;
+}
+/** The `ExtensionAPI` members that change or run the session. */
+export interface ExtensionSurface<M extends ModelRef = ModelRef> {
+    sendUserMessage(content: string, options?: {
+        expandPromptTemplates?: boolean;
+    }): void;
+    /** Resolve a model reference; false when it cannot be used or selected. */
+    setModel(model: M): Promise<boolean>;
+    getThinkingLevel(): ThinkingLevel;
+    setThinkingLevel(level: ThinkingLevel): void;
+}
+/** The interactive slice of `ctx.ui` the settings console uses (AC10). */
+export interface SettingsUi {
+    select(title: string, options: readonly string[]): Promise<string | undefined> | string | undefined;
+    input(title: string, placeholder?: string): Promise<string | undefined> | string | undefined;
+    confirm(title: string, message: string): Promise<boolean> | boolean;
+    notify(message: string, kind?: "info" | "warning" | "error"): void;
+}
+/**
+ * Everything a command handler needs from the invocation, reduced to what we
+ * read. `ModelLookup` is part of it because Pi exposes the registry through the
+ * context, not through the API object.
+ */
+export interface InvocationContext<M extends ModelRef = ModelRef> extends ModelLookup<M> {
+    readonly cwd: string;
+    /** The session's current model, or undefined when none is selected. */
+    readonly model: M | undefined;
+    isIdle(): boolean;
+    isProjectTrusted(): boolean;
+    /** Pi's `ctx.ui.notify` — the only channel an extension has to the operator. */
+    notify(message: string, kind?: "info" | "warning" | "error"): void;
+    /** Pi's `ctx.ui`. Routing only notifies through it; the console also asks. */
+    readonly ui: SettingsUi;
+    /** Pi's `ctx.modelRegistry.getAll()` — what the console can offer to pick from. */
+    availableModels(): readonly M[];
+}
+export type RefusalReason = "invalid-config" | "busy" | "routed-turn-in-flight" | "unavailable-route"
+/** `sendUserMessage` itself threw: the turn never started, so the routing is undone. */
+ | "dispatch-failed";
+export type DispatchOutcome = {
+    status: "dispatched";
+    routed: boolean;
+    hintShown: boolean;
+} | {
+    status: "refused";
+    reason: RefusalReason;
+    message: string;
+};
+/** Slash name of the settings console (SPEC S4, AC3, AC10). */
+export declare const SETTINGS_COMMAND = "agentic-workflow-settings";
+/**
+ * The router, as the settings console needs it: two verbs, already bound to the
+ * session they act on. Declared once because both the console's deps and the
+ * factory's handler type speak it, and a console that could call `settle` or
+ * `dispatch` would be a second owner of the latch.
+ */
+export interface RoutingControls {
+    inFlight(): boolean;
+    undoInFlight(): Promise<boolean>;
+}

package/dist/routing/types.js

@@ -0,0 +1,3 @@
+export const modelRefKey = (model) => `${model.provider}/${model.id}`;
+/** Slash name of the settings console (SPEC S4, AC3, AC10). */
+export const SETTINGS_COMMAND = "agentic-workflow-settings";

package/dist/settings/console.d.ts

@@ -0,0 +1,55 @@
+import type { RoutingControls, SettingsUi } from "../routing/types.js";
+import type { ConfigFile } from "../config/types.js";
+export interface SettingsDeps {
+    ui: SettingsUi;
+    agentDir: string;
+    cwd: string;
+    projectTrusted: boolean;
+    /** Routed command names — what the operator may attach an override to. */
+    commands: readonly string[];
+    /** `provider/modelId` references from the live registry, when one is reachable. */
+    models?: readonly string[];
+    readFile(path: string): string | null;
+    writeFile(path: string, text: string): void;
+    /**
+     * The router's live state, when the console was opened from a session that owns
+     * one. A routed turn that never settled — Pi starts it inside an action that
+     * swallows failures — leaves the latch held with no `agent_settled` coming, and
+     * every later command refuses. The operator needs a way out that is not
+     * "restart Pi", and the console is the only surface with room to explain it.
+     */
+    routing?: RoutingControls;
+}
+export type ConsoleOutcome = {
+    status: "saved";
+    scope: "global" | "project";
+    path: string;
+    file: ConfigFile;
+} | {
+    status: "cancelled";
+    edited: boolean;
+};
+/** The console's questions. `test/settings-console.test.mjs` drives the flow
+ * through these strings, so renaming one fails the tests that use it rather than
+ * silently re-sequencing them. */
+export declare const prompts: {
+    readonly scope: "Which file should the console edit?";
+    readonly menu: "What do you want to change?";
+    readonly inFlight: (command: string) => string;
+    readonly undoInFlight: "Undo a routing that never started";
+    readonly undone: "The routing was undone and the session put back.";
+    readonly command: "Which command?";
+    readonly policyChoice: "What should happen when a configured model is unavailable?";
+    readonly saveTo: (path: string) => string;
+    readonly discard: "Discard the draft?";
+    readonly setDefaultRoute: "Set the default route";
+    readonly setOverride: "Set a command override";
+    readonly clearOverride: "Clear a command override";
+    readonly policy: "Set the unavailable-route policy";
+    readonly save: "Save";
+    readonly cancel: "Cancel";
+    readonly model: (target: string) => string;
+    readonly modelPicked: (target: string) => string;
+    readonly thinking: (target: string) => string;
+};
+export declare function runSettingsConsole(deps: SettingsDeps): Promise<ConsoleOutcome>;

package/dist/settings/console.js

@@ -0,0 +1,266 @@
+// src/settings/console.ts
+// `/agentic-workflow-settings` (SPEC S4, S11, AC10, D-P8).
+//
+// The console edits **one file at a time** but always opens on the **merged**
+// view, because "what will this command actually run on?" is the only question an
+// operator has, and the answer depends on both scopes. Two rules keep it honest:
+// a scope whose file does not parse cannot be overwritten (that file is evidence
+// the operator must fix, not noise to clobber), and the project scope is refused
+// while the project is untrusted — the same gate the loader applies (AC13).
+import { loadConfig, configFilePaths } from "../config/load.js";
+import { parseConfigFile, parseModelReference } from "../config/schema.js";
+import { THINKING_LEVELS, UNAVAILABLE_ROUTE_POLICIES } from "../config/types.js";
+import { renderMergedConfig, routePath, DEFAULT_ROUTE } from "./view.js";
+/** The console's questions. `test/settings-console.test.mjs` drives the flow
+ * through these strings, so renaming one fails the tests that use it rather than
+ * silently re-sequencing them. */
+export const prompts = {
+    scope: "Which file should the console edit?",
+    menu: "What do you want to change?",
+    inFlight: (command) => `a routed /${command} is still held`,
+    undoInFlight: "Undo a routing that never started",
+    undone: "The routing was undone and the session put back.",
+    command: "Which command?",
+    policyChoice: "What should happen when a configured model is unavailable?",
+    saveTo: (path) => `Save the draft to ${path}?`,
+    discard: "Discard the draft?",
+    setDefaultRoute: "Set the default route",
+    setOverride: "Set a command override",
+    clearOverride: "Clear a command override",
+    policy: "Set the unavailable-route policy",
+    save: "Save",
+    cancel: "Cancel",
+    model: (target) => `Model for ${target}?`,
+    modelPicked: (target) => `Which model for ${target}?`,
+    thinking: (target) => `Thinking level for ${target}?`,
+};
+const GLOBAL_LABEL = "Global";
+const PROJECT_LABEL = "Project";
+const TYPED = "Type another reference…";
+const INHERIT = "inherit";
+export async function runSettingsConsole(deps) {
+    const paths = configFilePaths(deps.agentDir, deps.cwd);
+    deps.ui.notify(renderMergedConfig(loadConfig({ agentDir: deps.agentDir, cwd: deps.cwd, projectTrusted: deps.projectTrusted, readFile: deps.readFile }), deps.commands).join("\n"), "info");
+    const opened = await openAScope(deps, paths.global, paths.project);
+    if (!opened)
+        return { status: "cancelled", edited: false };
+    const { scope, path, original } = opened;
+    let draft = original;
+    for (;;) {
+        // Only offered while a turn actually holds the latch: an option that does
+        // nothing is how a console becomes noise.
+        const choice = await deps.ui.select(prompts.menu, [
+            prompts.setDefaultRoute,
+            prompts.setOverride,
+            prompts.clearOverride,
+            prompts.policy,
+            ...(deps.routing?.inFlight() ? [prompts.undoInFlight] : []),
+            prompts.save,
+            prompts.cancel,
+        ]);
+        if (choice === prompts.undoInFlight) {
+            const undone = (await deps.routing?.undoInFlight()) ?? false;
+            deps.ui.notify(undone ? prompts.undone : "Nothing was in flight.", undone ? "info" : "warning");
+            continue;
+        }
+        if (choice === undefined || choice === prompts.cancel) {
+            return { status: "cancelled", edited: dirty(draft, original) ? await discard(deps.ui) : false };
+        }
+        if (choice === prompts.setDefaultRoute) {
+            const edited = await editRoute(deps, DEFAULT_ROUTE);
+            if (edited)
+                draft = { ...draft, default: edited };
+            continue;
+        }
+        if (choice === prompts.setOverride) {
+            const name = await pickCommand(deps, commandChoices(deps, draft));
+            if (name === undefined)
+                continue;
+            const route = await editRoute(deps, name);
+            if (route)
+                draft = { ...draft, commands: { ...draft.commands, [name]: route } };
+            continue;
+        }
+        if (choice === prompts.clearOverride) {
+            const name = await pickCommand(deps, Object.keys(draft.commands ?? {}));
+            if (name === undefined)
+                continue;
+            const rest = { ...draft.commands };
+            delete rest[name];
+            draft = { ...draft, commands: rest };
+            continue;
+        }
+        if (choice === prompts.policy) {
+            const picked = await deps.ui.select(prompts.policyChoice, [...UNAVAILABLE_ROUTE_POLICIES]);
+            if (isPolicy(picked))
+                draft = { ...draft, onUnavailableRoute: picked };
+            continue;
+        }
+        if (choice === prompts.save) {
+            const saved = await saveScope(deps, scope, path, draft);
+            if (saved)
+                return { status: "saved", scope, path, file: clean(draft) };
+            continue;
+        }
+        deps.ui.notify(`Unknown choice: ${String(choice)}`, "warning");
+    }
+}
+/**
+ * Ask for a scope until one can be edited: an untrusted project is refused
+ * without being read, and a scope whose file does not parse is refused so the
+ * operator's own file survives (AC10, AC13).
+ */
+async function openAScope(deps, globalPath, projectPath) {
+    for (;;) {
+        const label = await deps.ui.select(prompts.scope, [GLOBAL_LABEL, PROJECT_LABEL]);
+        if (!label)
+            return undefined;
+        const scope = label === PROJECT_LABEL ? "project" : "global";
+        const path = scope === "project" ? projectPath : globalPath;
+        if (scope === "project" && !deps.projectTrusted) {
+            deps.ui.notify(`${path} is not editable while this project is untrusted — trust the project, or edit the global file instead.`, "warning");
+            continue;
+        }
+        const text = deps.readFile(path);
+        if (text === null)
+            return { scope, path, original: {} };
+        const parsed = parseFile(text, scope);
+        if (parsed.problems.length > 0) {
+            deps.ui.notify([`Nothing can be saved over an invalid ${scope} file (${path}):`, ...describe(parsed.problems)].join("\n"), "error");
+            continue;
+        }
+        return { scope, path, original: parsed.file };
+    }
+}
+/** Ask for a model and a thinking level; `undefined` means nothing changed. */
+async function editRoute(deps, target) {
+    const model = await askModel(deps, target);
+    if (model === undefined)
+        return undefined;
+    const thinking = await askThinking(deps, target);
+    if (thinking === undefined)
+        return undefined;
+    return { model, thinking };
+}
+async function askModel(deps, target) {
+    let answer;
+    if (deps.models && deps.models.length > 0) {
+        answer = await deps.ui.select(prompts.modelPicked(target), [...deps.models, TYPED]);
+        if (answer === TYPED || answer === undefined)
+            answer = await deps.ui.input(prompts.model(target), "provider/modelId or inherit");
+    }
+    else {
+        answer = await deps.ui.input(prompts.model(target), "provider/modelId or inherit");
+    }
+    if (answer === undefined)
+        return undefined;
+    const value = answer.trim();
+    if (value === INHERIT)
+        return INHERIT;
+    if (!/^[^/\s]+\/[^/\s]+$/.test(value)) {
+        // Rejected in the operator's terms and in the schema's: the value, and the
+        // field path the loader would name for the same mistake in a file (AC5).
+        deps.ui.notify(`Rejected: model must be "provider/modelId" or "inherit" — nothing was changed (${routePath(target)}.model).`, "error");
+        return undefined;
+    }
+    const parts = parseModelReference(value);
+    return parts ? `${parts.provider}/${parts.id}` : undefined;
+}
+async function askThinking(deps, target) {
+    const answer = await deps.ui.select(prompts.thinking(target), [...THINKING_LEVELS, INHERIT]);
+    if (answer === undefined)
+        return undefined;
+    if (answer === INHERIT || isThinkingLevel(answer))
+        return answer;
+    deps.ui.notify(`Rejected: thinking must be one of ${THINKING_LEVELS.join(", ")}, or "inherit" (${routePath(target)}.thinking).`, "error");
+    return undefined;
+}
+async function pickCommand(deps, options) {
+    if (options.length === 0) {
+        deps.ui.notify("There is no command to pick here.", "warning");
+        return undefined;
+    }
+    return deps.ui.select(prompts.command, [...options].sort((a, b) => a.localeCompare(b)));
+}
+function commandChoices(deps, draft) {
+    return [...new Set([...deps.commands, ...Object.keys(draft.commands ?? {})])];
+}
+async function saveScope(deps, scope, path, draft) {
+    const file = clean(draft);
+    const text = `${JSON.stringify(file, null, 2)}\n`;
+    const problems = problemsFor(file, scope);
+    if (problems.length > 0) {
+        deps.ui.notify(["Nothing saved — the draft is invalid:", ...describe(problems)].join("\n"), "error");
+        return false;
+    }
+    if (!(await deps.ui.confirm(prompts.saveTo(path), describeRouting(file)))) {
+        deps.ui.notify("Nothing saved.", "info");
+        return false;
+    }
+    deps.writeFile(path, text);
+    deps.ui.notify(`${scope === "project" ? "Project" : "Global"} routing saved to ${path}`, "info");
+    return true;
+}
+async function discard(ui) {
+    const dropped = await ui.confirm(prompts.discard, "Your edits are not in any config file yet.");
+    if (!dropped)
+        ui.notify("Draft kept — nothing was saved.", "info");
+    return Boolean(dropped);
+}
+function problemsFor(file, scope) {
+    // The draft is judged exactly as the file it would become — one validator, no
+    // second opinion that could disagree with the loader (P2).
+    return parseFile(JSON.stringify(file), scope).problems;
+}
+function withScope(issue, scope) {
+    return { scope, path: issue.path, message: issue.message };
+}
+/** The line the save confirmation repeats back, so the operator signs what they see. */
+function describeRouting(file) {
+    const routes = [
+        file.default ? `default: ${file.default.model ?? "inherit"} / ${file.default.thinking ?? "inherit"}` : "default: inherit / inherit",
+        ...Object.entries(file.commands ?? {}).map(([name, route]) => `${name}: ${route.model ?? "inherit"} / ${route.thinking ?? "inherit"}`),
+        `unavailable: ${file.onUnavailableRoute ?? "stop"}`,
+    ];
+    return routes.join(" · ");
+}
+/**
+ * Keep everything the file held or the operator set; drop only what says nothing
+ * (an empty route). Eliding by VALUE — treating an explicit `inherit` or `stop` as
+ * absent because a shipped default happens to agree — silently discards the only
+ * two moves that matter at project scope: switching a command off under a global
+ * route, and re-arming fail-closed over a global `inherit` (F4).
+ */
+function clean(draft) {
+    const file = {};
+    if (draft.default && Object.keys(draft.default).length > 0)
+        file.default = { ...draft.default };
+    const commands = {};
+    for (const [name, route] of Object.entries(draft.commands ?? {})) {
+        if (Object.keys(route).length > 0)
+            commands[name] = { ...route };
+    }
+    if (Object.keys(commands).length > 0)
+        file.commands = commands;
+    if (draft.onUnavailableRoute)
+        file.onUnavailableRoute = draft.onUnavailableRoute;
+    return file;
+}
+function parseFile(text, scope) {
+    const result = parseConfigFile(text);
+    return result.ok
+        ? { file: result.config, problems: [] }
+        : { file: {}, problems: result.issues.map((issue) => withScope(issue, scope)) };
+}
+function describe(problems) {
+    return problems.map((problem) => `  ${problem.path}: ${problem.message}`);
+}
+function dirty(a, b) {
+    return JSON.stringify(clean(a)) !== JSON.stringify(clean(b));
+}
+function isThinkingLevel(value) {
+    return THINKING_LEVELS.includes(value);
+}
+function isPolicy(value) {
+    return value === "stop" || value === "inherit";
+}

package/dist/settings/store.d.ts

@@ -0,0 +1,3 @@
+/** `null` when the file is absent, which the console reads as "nothing configured here". */
+export declare function readConfigFile(path: string): string | null;
+export declare function writeConfigFile(path: string, text: string): void;

package/dist/settings/store.js

@@ -0,0 +1,24 @@
+// src/settings/store.ts
+// The real filesystem behind the settings console's save (SPEC S4, AC10).
+//
+// Synchronous, like the loader: these are two small JSON files, and a read that
+// could not block would make the console's "what is in effect right now" view
+// race the dispatcher. Config is written 0600 with its parent created, because
+// the project scope's `.pi/` may not exist yet in a fresh clone.
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+/** `null` when the file is absent, which the console reads as "nothing configured here". */
+export function readConfigFile(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export function writeConfigFile(path, text) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, text, { mode: 0o600 });
+}

package/dist/settings/view.d.ts

@@ -0,0 +1,11 @@
+import type { LoadedConfig } from "../config/load.js";
+/** The label for the unqualified route, so `default` is never mistaken for a command name. */
+export declare const DEFAULT_ROUTE = "the default route";
+/**
+ * The field path the schema would report for a route target, e.g.
+ * `$.commands.plan-feature.model` — the same shape a config problem uses (AC5),
+ * so a rejection and a file error read identically to the operator.
+ */
+export declare function routePath(target: string): string;
+/** What the operator reads when the console opens. */
+export declare function renderMergedConfig(loaded: LoadedConfig, commands: readonly string[]): string[];

package/dist/settings/view.js

@@ -0,0 +1,46 @@
+// src/settings/view.ts
+// The settings console's display half (AC10, SPEC S4): what is in effect right
+// now, and which files the values came from.
+/** The label for the unqualified route, so `default` is never mistaken for a command name. */
+export const DEFAULT_ROUTE = "the default route";
+/**
+ * The field path the schema would report for a route target, e.g.
+ * `$.commands.plan-feature.model` — the same shape a config problem uses (AC5),
+ * so a rejection and a file error read identically to the operator.
+ */
+export function routePath(target) {
+    return target === DEFAULT_ROUTE ? "$.default" : `$.commands.${target}`;
+}
+/** What the operator reads when the console opens. */
+export function renderMergedConfig(loaded, commands) {
+    return [
+        "agentic-workflow routing — what each command runs on right now",
+        ...configLines(loaded.config, commands),
+        ...problems(loaded.problems),
+    ];
+}
+function configLines(config, commands) {
+    const overrides = Object.entries(config.commands).sort(([a], [b]) => a.localeCompare(b));
+    const total = Math.max(commands.length, overrides.length);
+    return [
+        `  default: ${route(config.default)}`,
+        ...(overrides.length === 0
+            ? ["  no per-command overrides — every command uses the default route"]
+            : [
+                ...overrides.map(([name, value]) => `  ${name}: ${route(value)}`),
+                `  ${overrides.length} of ${total} commands override the default route`,
+            ]),
+        `  when a configured model is unavailable: ${config.onUnavailableRoute}`,
+    ];
+}
+function route(value) {
+    return `${value.model} / ${value.thinking}`;
+}
+function problems(list) {
+    if (list.length === 0)
+        return [];
+    return [
+        "  files with problems — the values above fall back to the shipped defaults:",
+        ...list.map((issue) => `    ${issue.scope} config, ${issue.path}: ${issue.message}`),
+    ];
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@gtrabanco/pi-agentic-workflow",
+  "version": "0.1.0",
+  "description": "Pi package: canonical agentic-workflow skills, friendly slash commands, and per-command model routing.",
+  "keywords": [
+    "pi-package",
+    "agentic-workflow",
+    "pi",
+    "skills",
+    "workflow",
+    "model-routing"
+  ],
+  "license": "MIT",
+  "author": "Gabriel Trabanco <gtrabanco@users.noreply.github.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gtrabanco/agentic-workflow.git",
+    "directory": "packages/pi-agentic-workflow"
+  },
+  "homepage": "https://github.com/gtrabanco/agentic-workflow/tree/main/packages/pi-agentic-workflow#readme",
+  "type": "module",
+  "pi": {
+    "extensions": [
+      "./dist/extension/index.js"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "files": [
+    "dist",
+    "skills",
+    "package.json",
+    "README.md",
+    "README.es.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "bundle:skills": "node scripts/bundle-skills.mjs",
+    "test": "tsc && node --test test/*.test.mjs",
+    "prepublishOnly": "npm run build && npm test",
+    "mutation": "node scripts/mutation-check.mjs",
+    "prepare": "npm run build"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^24",
+    "typescript": "6"
+  }
+}