@tinyviber/a2h 0.1.0

package/dist/providers/mock.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockExecutor = createMockExecutor;
+const types_1 = require("./types");
+const SIMULATIONS = {
+    approve: {
+        taskStatus: 'succeeded',
+        runStatus: 'succeeded',
+        message: 'Approved. A downstream agent would now pick this up.',
+        steps: [
+            { title: 'Record decision', status: 'succeeded' },
+            { title: 'Notify owner', status: 'succeeded', detail: 'no agent connected — simulated' },
+            { title: 'Emit approved marker', status: 'succeeded' },
+        ],
+    },
+    reject: {
+        taskStatus: 'cancelled',
+        runStatus: 'succeeded',
+        message: 'Rejected. The task is closed without action.',
+        steps: [
+            { title: 'Record decision', status: 'succeeded' },
+            { title: 'Close task', status: 'succeeded' },
+        ],
+    },
+    retry: {
+        taskStatus: 'running',
+        runStatus: 'running',
+        message: 'Retry queued. A connected agent would re-run the task now.',
+        steps: [
+            { title: 'Requeue task', status: 'succeeded' },
+            { title: 'Dispatch to agent', status: 'pending', detail: 'no agent connected — simulated' },
+        ],
+    },
+    continue: {
+        taskStatus: 'running',
+        runStatus: 'running',
+        message: 'Continuing. Remaining work handed back to the agent.',
+        steps: [
+            { title: 'Acknowledge human input', status: 'succeeded' },
+            { title: 'Resume remaining steps', status: 'running' },
+        ],
+    },
+    run: {
+        taskStatus: 'running',
+        runStatus: 'running',
+        message: 'Run started (simulated).',
+        steps: [
+            { title: 'Prepare inputs', status: 'succeeded' },
+            { title: 'Execute', status: 'running', detail: 'simulated execution' },
+        ],
+    },
+    publish: {
+        taskStatus: 'succeeded',
+        runStatus: 'succeeded',
+        message: 'Publish simulated — nothing left this machine.',
+        steps: [
+            { title: 'Validate output', status: 'succeeded' },
+            { title: 'Publish', status: 'succeeded', detail: 'simulated, no external call' },
+        ],
+    },
+    open: {
+        taskStatus: 'info',
+        runStatus: 'succeeded',
+        message: 'Opened. No state change.',
+        steps: [{ title: 'Resolve target', status: 'succeeded' }],
+    },
+    discard: {
+        taskStatus: 'cancelled',
+        runStatus: 'succeeded',
+        message: 'Discarded (simulated). The artifact was not modified.',
+        steps: [{ title: 'Mark discarded', status: 'succeeded' }],
+    },
+    'apply-diff': {
+        taskStatus: 'succeeded',
+        runStatus: 'succeeded',
+        message: 'Apply simulated. No file on disk was modified.',
+        steps: [
+            { title: 'Check patch applies', status: 'succeeded' },
+            { title: 'Apply patch', status: 'succeeded', detail: 'simulated, files untouched' },
+        ],
+    },
+    'send-to-agent': {
+        taskStatus: 'running',
+        runStatus: 'running',
+        message: 'Handed to agent (simulated) — no provider connected.',
+        steps: [
+            { title: 'Package context', status: 'succeeded' },
+            { title: 'Deliver to agent', status: 'pending', detail: 'no provider connected' },
+        ],
+    },
+};
+const FALLBACK = {
+    taskStatus: 'succeeded',
+    runStatus: 'succeeded',
+    message: 'Action recorded (simulated).',
+    steps: [{ title: 'Record action', status: 'succeeded' }],
+};
+function createMockExecutor() {
+    const executor = {
+        id: 'mock',
+        description: 'Built-in simulator: changes A2H state only, never touches the system.',
+        handles() {
+            // The mock is the catch-all: it stands in for every action until a real
+            // provider registers itself ahead of it.
+            return true;
+        },
+        policy() {
+            // The honest answer for this executor, not a guess about the action: the
+            // mock changes A2H's own in-memory state and nothing else. No network,
+            // no shell, no writes.
+            //
+            // Note what this is *not*: a defence against a workspace that understates
+            // an action. A workspace can declare `sideEffect: "state"` for a publish
+            // and the mock will agree, because the mock really does nothing — there
+            // is no harm to prevent. The defence is that a *real* provider states its
+            // own policy and the merge takes the stricter of the two, so the same
+            // lie is caught the moment a provider that publishes is registered.
+            return { effect: 'state', confirmation: 'optional' };
+        },
+        execute(action, params, ctx) {
+            const sim = SIMULATIONS[action.kind] ?? FALLBACK;
+            const now = ctx.now.toISOString();
+            const steps = sim.steps.map((s, i) => ({
+                id: `${ctx.runId}-s${i + 1}`,
+                title: s.title,
+                status: s.status,
+                detail: s.detail,
+                at: now,
+            }));
+            const paramNote = formatParams(params);
+            const run = {
+                title: `${action.label}${action.target ? ` — ${action.target}` : ''}`,
+                status: sim.runStatus,
+                startedAt: now,
+                endedAt: sim.runStatus === 'running' ? undefined : now,
+                durationMs: sim.runStatus === 'running' ? undefined : 40,
+                summary: paramNote ? `${sim.message} (${paramNote})` : sim.message,
+                artifacts: [],
+                steps,
+                simulated: true,
+                blocks: [
+                    {
+                        type: 'notice',
+                        tone: 'info',
+                        text: 'This run was produced by the built-in mock executor. No agent, ' +
+                            'model, or shell command was involved.',
+                    },
+                ],
+            };
+            return {
+                message: sim.message,
+                taskStatus: sim.taskStatus,
+                run,
+                simulated: true,
+            };
+        },
+    };
+    return (0, types_1.markSimulated)(executor);
+}
+function formatParams(params) {
+    if (!params)
+        return '';
+    const entries = Object.entries(params).filter(([, v]) => v !== '');
+    if (entries.length === 0)
+        return '';
+    return entries.map(([k, v]) => `${k}=${truncate(v)}`).join(', ');
+}
+function truncate(v) {
+    return v.length > 60 ? `${v.slice(0, 57)}…` : v;
+}
+//# sourceMappingURL=mock.js.map

package/dist/providers/mock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.js","sourceRoot":"","sources":["../../src/providers/mock.ts"],"names":[],"mappings":";;AAwHA,gDAyEC;AA/LD,mCAAwC;AAuBxC,MAAM,WAAW,GAA+B;IAC9C,OAAO,EAAE;QACP,UAAU,EAAE,WAAW;QACvB,SAAS,EAAE,WAAW;QACtB,OAAO,EAAE,sDAAsD;QAC/D,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAE;YACjD,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,gCAAgC,EAAE;YACxF,EAAE,KAAK,EAAE,sBAAsB,EAAE,MAAM,EAAE,WAAW,EAAE;SACvD;KACF;IACD,MAAM,EAAE;QACN,UAAU,EAAE,WAAW;QACvB,SAAS,EAAE,WAAW;QACtB,OAAO,EAAE,8CAA8C;QACvD,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAE;YACjD,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE;SAC7C;KACF;IACD,KAAK,EAAE;QACL,UAAU,EAAE,SAAS;QACrB,SAAS,EAAE,SAAS;QACpB,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE;YAC9C,EAAE,KAAK,EAAE,mBAAmB,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,gCAAgC,EAAE;SAC5F;KACF;IACD,QAAQ,EAAE;QACR,UAAU,EAAE,SAAS;QACrB,SAAS,EAAE,SAAS;QACpB,OAAO,EAAE,sDAAsD;QAC/D,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,yBAAyB,EAAE,MAAM,EAAE,WAAW,EAAE;YACzD,EAAE,KAAK,EAAE,wBAAwB,EAAE,MAAM,EAAE,SAAS,EAAE;SACvD;KACF;IACD,GAAG,EAAE;QACH,UAAU,EAAE,SAAS;QACrB,SAAS,EAAE,SAAS;QACpB,OAAO,EAAE,0BAA0B;QACnC,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,WAAW,EAAE;YAChD,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,qBAAqB,EAAE;SACvE;KACF;IACD,OAAO,EAAE;QACP,UAAU,EAAE,WAAW;QACvB,SAAS,EAAE,WAAW;QACtB,OAAO,EAAE,gDAAgD;QACzD,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAE;YACjD,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,6BAA6B,EAAE;SACjF;KACF;IACD,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM;QAClB,SAAS,EAAE,WAAW;QACtB,OAAO,EAAE,0BAA0B;QACnC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;KAC1D;IACD,OAAO,EAAE;QACP,UAAU,EAAE,WAAW;QACvB,SAAS,EAAE,WAAW;QACtB,OAAO,EAAE,uDAAuD;QAChE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;KAC1D;IACD,YAAY,EAAE;QACZ,UAAU,EAAE,WAAW;QACvB,SAAS,EAAE,WAAW;QACtB,OAAO,EAAE,gDAAgD;QACzD,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,qBAAqB,EAAE,MAAM,EAAE,WAAW,EAAE;YACrD,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,4BAA4B,EAAE;SACpF;KACF;IACD,eAAe,EAAE;QACf,UAAU,EAAE,SAAS;QACrB,SAAS,EAAE,SAAS;QACpB,OAAO,EAAE,sDAAsD;QAC/D,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAE;YACjD,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,uBAAuB,EAAE;SAClF;KACF;CACF,CAAC;AAEF,MAAM,QAAQ,GAAe;IAC3B,UAAU,EAAE,WAAW;IACvB,SAAS,EAAE,WAAW;IACtB,OAAO,EAAE,8BAA8B;IACvC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;CACzD,CAAC;AAEF,SAAgB,kBAAkB;IAChC,MAAM,QAAQ,GAAmB;QAC/B,EAAE,EAAE,MAAM;QACV,WAAW,EAAE,uEAAuE;QAEpF,OAAO;YACL,wEAAwE;YACxE,yCAAyC;YACzC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM;YACJ,yEAAyE;YACzE,uEAAuE;YACvE,uBAAuB;YACvB,EAAE;YACF,0EAA0E;YAC1E,yEAAyE;YACzE,wEAAwE;YACxE,0EAA0E;YAC1E,sEAAsE;YACtE,oEAAoE;YACpE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,CAAC;QACvD,CAAC;QAED,OAAO,CACL,MAAkB,EAClB,MAA0C,EAC1C,GAAkB;YAElB,MAAM,GAAG,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,QAAQ,CAAC;YACjD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;YAElC,MAAM,KAAK,GAAc,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;gBAChD,EAAE,EAAE,GAAG,GAAG,CAAC,KAAK,KAAK,CAAC,GAAG,CAAC,EAAE;gBAC5B,KAAK,EAAE,CAAC,CAAC,KAAK;gBACd,MAAM,EAAE,CAAC,CAAC,MAAM;gBAChB,MAAM,EAAE,CAAC,CAAC,MAAM;gBAChB,EAAE,EAAE,GAAG;aACR,CAAC,CAAC,CAAC;YAEJ,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;YACvC,MAAM,GAAG,GAAqD;gBAC5D,KAAK,EAAE,GAAG,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;gBACrE,MAAM,EAAE,GAAG,CAAC,SAAS;gBACrB,SAAS,EAAE,GAAG;gBACd,OAAO,EAAE,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG;gBACtD,UAAU,EAAE,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;gBACxD,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,KAAK,SAAS,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO;gBAClE,SAAS,EAAE,EAAE;gBACb,KAAK;gBACL,SAAS,EAAE,IAAI;gBACf,MAAM,EAAE;oBACN;wBACE,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,MAAM;wBACZ,IAAI,EACF,iEAAiE;4BACjE,uCAAuC;qBAC1C;iBACF;aACF,CAAC;YAEF,OAAO;gBACL,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,UAAU,EAAE,GAAG,CAAC,UAAU;gBAC1B,GAAG;gBACH,SAAS,EAAE,IAAI;aAChB,CAAC;QACJ,CAAC;KACF,CAAC;IAEF,OAAO,IAAA,qBAAa,EAAC,QAAQ,CAAC,CAAC;AACjC,CAAC;AAED,SAAS,YAAY,CAAC,MAA0C;IAC9D,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IACvB,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;IACnE,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACpC,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnE,CAAC;AAED,SAAS,QAAQ,CAAC,CAAS;IACzB,OAAO,CAAC,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAClD,CAAC"}

package/dist/providers/registry.d.ts

@@ -0,0 +1,12 @@
+import { type ActionExecutor, type ProviderRegistry } from './types';
+export interface RegistryOptions {
+    extraExecutors?: ActionExecutor[];
+    /** Disable the built-in simulator entirely (used by tests). */
+    withoutMock?: boolean;
+}
+export declare function createDefaultRegistry(options?: RegistryOptions): ProviderRegistry;
+export { createMockExecutor } from './mock';
+export type { ActionExecutor, ActionResolution, ProviderRegistry, ExecutionOutcome, ActionContext, } from './types';
+/** Everything a caller needs to reason about run provenance. */
+export declare function describeProviders(registry: ProviderRegistry): string;
+//# sourceMappingURL=registry.d.ts.map

package/dist/providers/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/providers/registry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAUrF,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;IAClC,+DAA+D;IAC/D,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,eAAoB,GAAG,gBAAgB,CAIrF;AAED,OAAO,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAC5C,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,GACd,MAAM,SAAS,CAAC;AAEjB,gEAAgE;AAChE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAEpE"}

package/dist/providers/registry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockExecutor = void 0;
+exports.createDefaultRegistry = createDefaultRegistry;
+exports.describeProviders = describeProviders;
+const mock_1 = require("./mock");
+const types_1 = require("./types");
+function createDefaultRegistry(options = {}) {
+    const executors = [...(options.extraExecutors ?? [])];
+    if (!options.withoutMock)
+        executors.push((0, mock_1.createMockExecutor)());
+    return (0, types_1.createRegistry)(executors);
+}
+var mock_2 = require("./mock");
+Object.defineProperty(exports, "createMockExecutor", { enumerable: true, get: function () { return mock_2.createMockExecutor; } });
+/** Everything a caller needs to reason about run provenance. */
+function describeProviders(registry) {
+    return registry.executors.map((e) => `${e.id} (${e.description})`).join('; ');
+}
+//# sourceMappingURL=registry.js.map

package/dist/providers/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/providers/registry.ts"],"names":[],"mappings":";;;AAkBA,sDAIC;AAYD,8CAEC;AAnCD,iCAA4C;AAC5C,mCAAqF;AAgBrF,SAAgB,qBAAqB,CAAC,UAA2B,EAAE;IACjE,MAAM,SAAS,GAAqB,CAAC,GAAG,CAAC,OAAO,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,CAAC;IACxE,IAAI,CAAC,OAAO,CAAC,WAAW;QAAE,SAAS,CAAC,IAAI,CAAC,IAAA,yBAAkB,GAAE,CAAC,CAAC;IAC/D,OAAO,IAAA,sBAAc,EAAC,SAAS,CAAC,CAAC;AACnC,CAAC;AAED,+BAA4C;AAAnC,0GAAA,kBAAkB,OAAA;AAS3B,gEAAgE;AAChE,SAAgB,iBAAiB,CAAC,QAA0B;IAC1D,OAAO,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAChF,CAAC"}

package/dist/providers/types.d.ts

@@ -0,0 +1,64 @@
+import type { ActionView, EffectPolicy, RunView } from '../types';
+export interface ActionContext {
+    /** Workspace root, so an executor can write real artifacts if it wants to. */
+    workspaceRoot: string;
+    /** Id assigned to the run this execution will produce. */
+    runId: string;
+    now: Date;
+}
+export interface ExecutionOutcome {
+    /** Human-readable result line shown back in the UI. */
+    message: string;
+    /** New status for the owning task, when the action changes it. */
+    taskStatus?: string;
+    /** Run record to append, when the executor produced one. */
+    run?: Omit<RunView, 'id' | 'taskId'> & {
+        id?: string;
+    };
+    /** Whether the effect really happened. A simulation must say `true`. */
+    simulated: boolean;
+}
+export interface ActionExecutor {
+    /** Stable id, e.g. "mock" or "workbuddy". */
+    id: string;
+    /** Description shown in diagnostics, not in the main UI. */
+    description: string;
+    handles(action: ActionView): boolean;
+    /**
+     * What this executor will actually do with the action, and whether the human
+     * has to confirm first. Required, not optional: writing a provider means
+     * stating its effect, and A2H will not run one that has not said.
+     */
+    policy(action: ActionView): EffectPolicy;
+    execute(action: ActionView, params: Record<string, string> | undefined, ctx: ActionContext): Promise<ExecutionOutcome> | ExecutionOutcome;
+}
+/** The answer to "what happens if I click this?" — computed, not guessed. */
+export interface ActionResolution {
+    executor: ActionExecutor;
+    /** True when this executor only simulates the effect. */
+    simulated: boolean;
+    /** The executor's authoritative policy for this action. */
+    policy: EffectPolicy;
+}
+export interface ProviderRegistry {
+    executors: ActionExecutor[];
+    /**
+     * Resolves the single executor that owns an action, with its provenance and
+     * its policy. This is the only supported way to ask "who runs this?" —
+     * asking the registry as a whole cannot answer it per action.
+     */
+    resolve(action: ActionView): ActionResolution | undefined;
+    /** Convenience for callers that only need the executor. */
+    findExecutor(action: ActionView): ActionExecutor | undefined;
+    /**
+     * True when *every* registered executor is a simulation, i.e. nothing real
+     * is connected. Never use this to label an individual action: a workspace
+     * can mix a real provider with the built-in simulator, and then this is
+     * false while some actions are still simulated. Use `resolve()`.
+     */
+    readonly allSimulated: boolean;
+}
+export declare function createRegistry(executors: ActionExecutor[]): ProviderRegistry;
+/** Marks an executor as a simulation so the UI can say so plainly. */
+export declare function markSimulated<T extends ActionExecutor>(executor: T): T;
+//# sourceMappingURL=types.d.ts.map

package/dist/providers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/providers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAyBlE,MAAM,WAAW,aAAa;IAC5B,8EAA8E;IAC9E,aAAa,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,IAAI,CAAC;CACX;AAED,MAAM,WAAW,gBAAgB;IAC/B,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,GAAG,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,QAAQ,CAAC,GAAG;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACvD,wEAAwE;IACxE,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,6CAA6C;IAC7C,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC;IACrC;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,YAAY,CAAC;IACzC,OAAO,CACL,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EAC1C,GAAG,EAAE,aAAa,GACjB,OAAO,CAAC,gBAAgB,CAAC,GAAG,gBAAgB,CAAC;CACjD;AAED,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,cAAc,CAAC;IACzB,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,2DAA2D;IAC3D,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAC1D,2DAA2D;IAC3D,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,cAAc,GAAG,SAAS,CAAC;IAC7D;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,gBAAgB,CAmB5E;AAID,sEAAsE;AACtE,wBAAgB,aAAa,CAAC,CAAC,SAAS,cAAc,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAGtE"}

package/dist/providers/types.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRegistry = createRegistry;
+exports.markSimulated = markSimulated;
+function createRegistry(executors) {
+    return {
+        executors,
+        resolve(action) {
+            const executor = executors.find((e) => e.handles(action));
+            if (!executor)
+                return undefined;
+            return {
+                executor,
+                simulated: isSimulated(executor),
+                policy: executor.policy(action),
+            };
+        },
+        findExecutor(action) {
+            return executors.find((e) => e.handles(action));
+        },
+        get allSimulated() {
+            return executors.length > 0 && executors.every((e) => isSimulated(e));
+        },
+    };
+}
+const SIMULATED = new WeakSet();
+/** Marks an executor as a simulation so the UI can say so plainly. */
+function markSimulated(executor) {
+    SIMULATED.add(executor);
+    return executor;
+}
+/**
+ * Registered as a simulation either by name or by declaration. The id check
+ * catches an executor constructed elsewhere; being wrong in this direction
+ * under-promises a real effect, which is the side to err on.
+ */
+function isSimulated(executor) {
+    return SIMULATED.has(executor) || executor.id === 'mock';
+}
+//# sourceMappingURL=types.js.map

package/dist/providers/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/providers/types.ts"],"names":[],"mappings":";;AA2FA,wCAmBC;AAKD,sCAGC;AA3BD,SAAgB,cAAc,CAAC,SAA2B;IACxD,OAAO;QACL,SAAS;QACT,OAAO,CAAC,MAAM;YACZ,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;YAC1D,IAAI,CAAC,QAAQ;gBAAE,OAAO,SAAS,CAAC;YAChC,OAAO;gBACL,QAAQ;gBACR,SAAS,EAAE,WAAW,CAAC,QAAQ,CAAC;gBAChC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;aAChC,CAAC;QACJ,CAAC;QACD,YAAY,CAAC,MAAM;YACjB,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QAClD,CAAC;QACD,IAAI,YAAY;YACd,OAAO,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACxE,CAAC;KACF,CAAC;AACJ,CAAC;AAED,MAAM,SAAS,GAAG,IAAI,OAAO,EAAkB,CAAC;AAEhD,sEAAsE;AACtE,SAAgB,aAAa,CAA2B,QAAW;IACjE,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACxB,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;GAIG;AACH,SAAS,WAAW,CAAC,QAAwB;IAC3C,OAAO,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,EAAE,KAAK,MAAM,CAAC;AAC3D,CAAC"}

package/dist/renderer/assets/index.html

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <meta name="color-scheme" content="light" />
+  <!-- Filled in by the server at serve time with this process's session token.
+       Empty when the shell is opened without a server, in which case nothing
+       that mutates state will work — which is the intended outcome. -->
+  <meta name="a2h-token" content="" />
+  <title>A2H</title>
+  <link rel="stylesheet" href="/styles.css" />
+</head>
+<body>
+  <div class="app" id="app">
+    <button class="nav-toggle" id="navToggle" type="button" aria-label="Toggle navigation" aria-expanded="false">
+      <span class="nav-toggle-bar"></span>
+      <span class="nav-toggle-bar"></span>
+      <span class="nav-toggle-bar"></span>
+    </button>
+    <div class="scrim" id="scrim" hidden></div>
+
+    <aside class="sidebar" id="sidebar" aria-label="Navigation">
+      <div class="sidebar-inner">
+        <a class="brand" href="#/" id="brand">
+          <span class="brand-mark">A2H</span>
+          <span class="brand-sub">Agent&nbsp;to&nbsp;Human</span>
+        </a>
+        <nav class="nav" id="nav" aria-label="Sections"></nav>
+        <div class="sidebar-foot" id="sidebarFoot"></div>
+      </div>
+    </aside>
+
+    <main class="main" id="main">
+      <div class="content" id="content" aria-live="polite"></div>
+    </main>
+  </div>
+
+  <script type="module" src="/js/main.js"></script>
+</body>
+</html>

package/dist/renderer/assets/js/actions.js

@@ -0,0 +1,205 @@
+// The human's control surface.
+//
+// Design rules that come straight from design.md: actions are quiet buttons,
+// confirmation happens inline rather than in a modal, and anything simulated
+// says so plainly. A human should never be unsure whether their click left
+// this machine.
+
+import { el } from './dom.js';
+import { emit } from './bus.js';
+import { executeAction } from './api.js';
+import { findAction, getActionResult, isPending, setActionResult, setPending } from './store.js';
+import { statusTone } from './format.js';
+
+const SIDE_EFFECT_LABEL = {
+  none: 'no side effect',
+  state: 'changes state here',
+  external: 'reaches outside A2H',
+};
+
+export function renderActions(ids, options = {}) {
+  const actions = ids.map((id) => findAction(id)).filter(Boolean);
+  if (actions.length === 0) return null;
+
+  const box = el('div', { class: 'actions' });
+  for (const action of actions) {
+    box.appendChild(actionRow(action, options));
+  }
+  return box;
+}
+
+function actionRow(action, options) {
+  const row = el('div', { class: 'action-row' });
+
+  // `compact` trims the descriptive chrome, nothing else. It used to hide the
+  // parameter inputs too, which made any action with required params
+  // impossible to run from a block: the button could only ever come back
+  // "missing required input". An action that asks for a value needs a field to
+  // put it in, wherever it is rendered.
+  if (!options.compact && (action.description || action.sideEffect !== 'none')) {
+    const meta = [];
+    if (action.sideEffect !== 'none') meta.push(SIDE_EFFECT_LABEL[action.sideEffect] || action.sideEffect);
+    if (action.simulated) meta.push('simulated');
+    row.appendChild(
+      el('div', { class: 'action-meta' }, [
+        action.description ? el('span', { class: 'action-desc', text: action.description }) : null,
+        meta.length ? el('span', { class: 'action-note', text: meta.join(' · ') }) : null,
+      ]),
+    );
+  }
+
+  const controls = el('div', { class: 'action-controls' });
+  const inputs = new Map();
+
+  if (action.params && action.params.length) {
+    const form = el('div', { class: 'action-params' });
+    for (const param of action.params) {
+      const input = paramInput(param, inputs);
+      form.appendChild(
+        el('label', { class: 'action-param' }, [
+          el('span', { class: 'action-param-label', text: param.label + (param.required ? ' *' : '') }),
+          input,
+        ]),
+      );
+    }
+    controls.appendChild(form);
+  }
+
+  const button = el('button', {
+    class: 'btn action-btn',
+    type: 'button',
+    disabled: !action.enabled || isPending(action.id),
+    text: isPending(action.id) ? 'Working…' : action.label,
+  });
+  controls.appendChild(button);
+
+  const confirmBox = el('div', { class: 'action-confirm', hidden: true });
+  const resultBox = el('div', { class: 'action-result' });
+  renderResult(resultBox, getActionResult(action.id));
+
+  button.addEventListener('click', () => {
+    if (action.confirm) {
+      confirmBox.hidden = false;
+      confirmBox.textContent = '';
+      confirmBox.appendChild(
+        el('span', { class: 'action-confirm-text',
+          text: `“${action.label}” ${SIDE_EFFECT_LABEL[action.sideEffect] || 'has a side effect'}. Continue?` }),
+      );
+      confirmBox.appendChild(
+        el('button', {
+          class: 'btn action-confirm-yes',
+          type: 'button',
+          text: 'Continue',
+          onclick: () => {
+            confirmBox.hidden = true;
+            run(action, inputs, button, resultBox);
+          },
+        }),
+      );
+      confirmBox.appendChild(
+        el('button', {
+          class: 'btn action-confirm-no',
+          type: 'button',
+          text: 'Cancel',
+          onclick: () => {
+            confirmBox.hidden = true;
+          },
+        }),
+      );
+      return;
+    }
+    run(action, inputs, button, resultBox);
+  });
+
+  row.appendChild(controls);
+  row.appendChild(confirmBox);
+  row.appendChild(resultBox);
+  return row;
+}
+
+function paramInput(param, inputs) {
+  const type = param.type || 'text';
+  if (type === 'textarea') {
+    const node = el('textarea', { class: 'input', rows: 3, placeholder: param.placeholder || '' });
+    if (param.default != null) node.value = String(param.default);
+    inputs.set(param.name, () => node.value);
+    return node;
+  }
+  if (type === 'select') {
+    const node = el('select', { class: 'input' });
+    for (const option of param.options || []) {
+      node.appendChild(el('option', { value: option, text: option }));
+    }
+    if (param.default != null) node.value = String(param.default);
+    inputs.set(param.name, () => node.value);
+    return node;
+  }
+  if (type === 'boolean') {
+    const node = el('input', { type: 'checkbox', class: 'checkbox' });
+    if (param.default === true) node.checked = true;
+    inputs.set(param.name, () => (node.checked ? 'true' : 'false'));
+    return node;
+  }
+  const node = el('input', { type: 'text', class: 'input', placeholder: param.placeholder || '' });
+  if (param.default != null) node.value = String(param.default);
+  inputs.set(param.name, () => node.value);
+  return node;
+}
+
+async function run(action, inputs, button, resultBox) {
+  const params = {};
+  for (const [name, read] of inputs) params[name] = read();
+
+  setPending(action.id, true);
+  button.disabled = true;
+  button.textContent = 'Working…';
+
+  let result;
+  try {
+    result = await executeAction({ id: action.id, params, confirm: true });
+  } catch (err) {
+    result = { ok: false, message: `Could not reach the server: ${err.message}`, simulated: false };
+  }
+
+  setPending(action.id, false);
+  setActionResult(action.id, result);
+  button.disabled = !action.enabled;
+  button.textContent = action.label;
+  renderResult(resultBox, result);
+
+  if (result.ok) {
+    // Task status and runs changed on the server — pull the new presentation.
+    emit('refresh');
+  }
+}
+
+function renderResult(box, result) {
+  box.textContent = '';
+  if (!result) return;
+  const tone = result.ok ? statusTone('succeeded') : statusTone('failed');
+  box.appendChild(
+    el('div', { class: `action-outcome tone-${tone}` }, [
+      el('span', { class: 'action-outcome-text', text: result.message || (result.ok ? 'Done.' : 'Failed.') }),
+      result.ok && result.simulated ? el('span', { class: 'action-sim', text: 'simulated' }) : null,
+    ]),
+  );
+}
+
+/** Compact audit trail, shown on the actions page. */
+export function renderAudit(entries) {
+  if (!entries || entries.length === 0) {
+    return el('p', { class: 'empty', text: 'No actions have been taken in this session.' });
+  }
+  const list = el('div', { class: 'audit' });
+  for (const entry of entries) {
+    list.appendChild(
+      el('div', { class: `audit-row${entry.ok ? '' : ' is-failed'}` }, [
+        el('span', { class: 'audit-time', text: new Date(entry.at).toLocaleTimeString() }),
+        el('span', { class: 'audit-action', text: entry.actionId }),
+        el('span', { class: 'audit-executor', text: entry.executor }),
+        el('span', { class: 'audit-message', text: entry.message }),
+      ]),
+    );
+  }
+  return list;
+}

package/dist/renderer/assets/js/api.js

@@ -0,0 +1,75 @@
+// Server communication. The viewer talks to exactly four endpoints; keeping
+// them in one file makes the surface easy to audit.
+
+let presentationPromise = null;
+
+export function loadPresentation(force) {
+  if (!force && presentationPromise) return presentationPromise;
+  presentationPromise = fetchJson('/api/presentation');
+  return presentationPromise;
+}
+
+export function invalidate() {
+  presentationPromise = null;
+}
+
+export function loadArtifact(path, mode) {
+  const suffix = mode === 'full' ? '&mode=full' : '';
+  return fetchJson(`/api/artifact?path=${encodeURIComponent(path)}${suffix}`);
+}
+
+/**
+ * Executes a declared action. The server owns the allowlist and the
+ * confirmation boundary; this function only carries the request.
+ *
+ * Mutating requests have to present the session token the server injected into
+ * this page. It is not a password and not a login — it exists so that another
+ * page in the same browser cannot forge a request to a localhost control API,
+ * which is exactly what makes it worth carrying on every call rather than
+ * fetching once and trusting the result.
+ */
+export async function executeAction(payload) {
+  const res = await fetch('/api/action', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'X-A2H-Token': sessionToken() },
+    body: JSON.stringify(payload),
+  });
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    body = { ok: false, error: 'bad_response', message: 'The server returned an unreadable response.' };
+  }
+  return body;
+}
+
+function sessionToken() {
+  const meta = document.querySelector('meta[name="a2h-token"]');
+  return meta ? meta.getAttribute('content') || '' : '';
+}
+
+/** Subscribes to workspace change / action events. Returns a close function. */
+export function openEvents(handlers) {
+  let source;
+  try {
+    source = new EventSource('/api/events');
+  } catch {
+    return () => {};
+  }
+  source.addEventListener('change', () => handlers.onChange && handlers.onChange());
+  source.addEventListener('action', () => handlers.onAction && handlers.onAction());
+  source.onerror = () => {
+    /* EventSource reconnects on its own. */
+  };
+  return () => source.close();
+}
+
+async function fetchJson(url) {
+  const res = await fetch(url, { headers: { Accept: 'application/json' } });
+  if (!res.ok) {
+    const error = new Error(`${res.status}`);
+    error.status = res.status;
+    throw error;
+  }
+  return res.json();
+}