@arnilo/prism 0.0.1 → 0.0.2

package/dist/contracts.js

@@ -1,2 +1,42 @@
-export {};
+export const SESSION_ENTRY_KINDS = [
+    "message",
+    "event",
+    "summary",
+    "metadata",
+    "model_change",
+    "label",
+    "custom",
+    "compaction",
+];
+const SESSION_ENTRY_KIND_SET = new Set(SESSION_ENTRY_KINDS);
+export const SESSION_ENTRY_SCHEMA_VERSION = 1;
+export function isSessionEntryKind(value) {
+    return typeof value === "string" && SESSION_ENTRY_KIND_SET.has(value);
+}
+/** Stable error code carried by `SessionAppendConflictError`. */
+export const SESSION_APPEND_CONFLICT_CODE = "session_append_conflict";
+/**
+ * Thrown when `SessionStore.append` rejects an entry under `SessionAppendOptions`
+ * (dangling/stale `expectedParentId`, stricter adapter CAS failure, or duplicate
+ * idempotency key for the same parent). Recognize via the stable `code` and
+ * `isSessionAppendConflict`, not message text.
+ */
+export class SessionAppendConflictError extends Error {
+    conflict;
+    code = SESSION_APPEND_CONFLICT_CODE;
+    constructor(conflict) {
+        const detail = conflict.idempotencyDuplicate
+            ? `idempotency key already used`
+            : conflict.currentLeafId !== undefined
+                ? `expected parent ${conflict.expectedParentId ?? "<none>"} does not match current leaf ${conflict.currentLeafId}`
+                : `expected parent ${conflict.expectedParentId ?? "<none>"} is unavailable`;
+        super(`session append conflict: ${detail}`);
+        this.conflict = conflict;
+        this.name = "SessionAppendConflictError";
+    }
+}
+/** Type guard keyed off the stable `code` (works across bundles; not message text). */
+export function isSessionAppendConflict(error) {
+    return error instanceof Error && error.code === SESSION_APPEND_CONFLICT_CODE;
+}
 //# sourceMappingURL=contracts.js.map

package/dist/contribution-parsing.d.ts

@@ -0,0 +1,19 @@
+import type { Skill } from "./contracts.js";
+import type { ManifestContributionDeclaration } from "./manifests.js";
+/** Split a markdown file with `---` frontmatter into a parsed map and body.
+ *  Exported so Node-side loaders (e.g. agent bundle resolution) can reuse the
+ *  same frontmatter parser without duplicating it. */
+export declare function splitFrontmatter(text: string, path: string): {
+    front: Map<string, unknown>;
+    body: string;
+};
+/** Parse a `SKILL.md` into a {@link Skill}. Frontmatter keys map to `name`
+ *  (required), `description`, `toolNames` (comma- or YAML-list); the markdown
+ *  body becomes `instructions`. `context` declared in a file is surfaced as
+ *  metadata only — file-declared context providers need a `module`; Phase 30
+ *  owns instruction injection and context wiring. */
+export declare function parseSkillFile(text: string, path: string): Skill;
+/** Parse a per-agent `AGENT.md` bundle frontmatter file into a manifest-referenced declaration.
+ *  Only `name`/`metadata` surface here; full agent resolution is Phase 33's
+ *  `resolveAgentDefinition`. The file path is recorded as `resource`. */
+export declare function parseAgentFile(text: string, path: string): ManifestContributionDeclaration;

package/dist/contribution-parsing.js

@@ -0,0 +1,124 @@
+/** Frontmatter split + scalar/simple-list parser for `SKILL.md` and agent bundle
+ *  markdown files. Stdlib `String` parsing only — no YAML dependency, no Markdown
+ *  AST, no `node:*` import. Unknown frontmatter keys are tolerated (collected into
+ *  metadata, not fatal). Core is fs-free: callers pass file text already read. */
+const FENCE = "---";
+/** Split a markdown file with `---` frontmatter into a parsed map and body.
+ *  Exported so Node-side loaders (e.g. agent bundle resolution) can reuse the
+ *  same frontmatter parser without duplicating it. */
+export function splitFrontmatter(text, path) {
+    const lines = text.split(/\r?\n/);
+    if (lines.length === 0 || lines[0].trim() !== FENCE) {
+        return { front: new Map(), body: text };
+    }
+    let end = -1;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i].trim() === FENCE || lines[i].trim() === "...") {
+            end = i;
+            break;
+        }
+    }
+    if (end === -1)
+        throw new Error(`Malformed frontmatter in ${path}: unterminated fence`);
+    const frontLines = lines.slice(1, end);
+    const body = lines.slice(end + 1).join("\n");
+    return { front: parseFrontBlock(frontLines), body };
+}
+function parseFrontBlock(lines) {
+    const out = new Map();
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim() === "") {
+            i++;
+            continue;
+        }
+        const colon = line.indexOf(":");
+        if (colon === -1) {
+            i++;
+            continue;
+        }
+        const key = line.slice(0, colon).trim();
+        const value = line.slice(colon + 1).trim();
+        if (value === "") {
+            // block list: collect following ` - item` lines
+            const items = [];
+            while (i + 1 < lines.length && /^\s*-\s+/.test(lines[i + 1])) {
+                items.push(lines[i + 1].replace(/^\s*-\s+/, "").trim());
+                i++;
+            }
+            out.set(key, items);
+        }
+        else if (value.startsWith("[") && value.endsWith("]")) {
+            out.set(key, value.slice(1, -1).split(",").map((s) => s.trim()).filter((s) => s.length > 0));
+        }
+        else {
+            out.set(key, value);
+        }
+        i++;
+    }
+    return out;
+}
+// ponytail: core is fs-free — derive the fallback skill name from the path via a
+// plain string split instead of `node:path`. Expects `.../<name>/SKILL.md`.
+function parentDirName(path) {
+    const parts = path.split(/[/\\]+/).filter(Boolean);
+    return parts.length >= 2 ? parts[parts.length - 2] : parts[parts.length - 1] ?? "";
+}
+const NAME_RE = /^[A-Za-z0-9 _-]+$/;
+/** Parse a `SKILL.md` into a {@link Skill}. Frontmatter keys map to `name`
+ *  (required), `description`, `toolNames` (comma- or YAML-list); the markdown
+ *  body becomes `instructions`. `context` declared in a file is surfaced as
+ *  metadata only — file-declared context providers need a `module`; Phase 30
+ *  owns instruction injection and context wiring. */
+export function parseSkillFile(text, path) {
+    const { front, body } = splitFrontmatter(text, path);
+    const name = String(front.get("name") ?? "").trim() || parentDirName(path);
+    if (!NAME_RE.test(name)) {
+        throw new Error(`Invalid skill name in ${path}: ${JSON.stringify(name)}`);
+    }
+    const description = front.has("description") ? String(front.get("description")) : undefined;
+    const toolNamesValue = front.get("toolNames") ?? front.get("tools");
+    const toolNames = Array.isArray(toolNamesValue) ? toolNamesValue : undefined;
+    const metadata = {};
+    // ponytail: `context` from a file SKILL.md lands here as metadata; not wired into a live ContextProvider (needs a module). Phase 30.
+    for (const [key, value] of front) {
+        if (key !== "name" && key !== "description" && key !== "toolNames" && key !== "tools") {
+            metadata[key] = value;
+        }
+    }
+    const skill = {
+        name: name.replace(/\s+/g, "-"),
+        description,
+        instructions: body.replace(/^\n+/, ""),
+        ...(toolNames ? { toolNames } : {}),
+        ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+    };
+    return skill;
+}
+/** Parse a per-agent `AGENT.md` bundle frontmatter file into a manifest-referenced declaration.
+ *  Only `name`/`metadata` surface here; full agent resolution is Phase 33's
+ *  `resolveAgentDefinition`. The file path is recorded as `resource`. */
+export function parseAgentFile(text, path) {
+    const { front } = splitFrontmatter(text, path);
+    const name = String(front.get("name") ?? "").trim() || parentDirName(path);
+    if (!NAME_RE.test(name)) {
+        throw new Error(`Invalid agent name in ${path}: ${JSON.stringify(name)}`);
+    }
+    // ponytail: full resolution is Phase 33's resolveAgentDefinition. Only name/metadata surface here.
+    const metadata = {};
+    for (const [key, value] of front) {
+        if (key !== "name")
+            metadata[key] = value;
+    }
+    const declaration = {
+        kind: "agent",
+        name: name.replace(/\s+/g, "-"),
+        resource: path,
+        ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+    };
+    return declaration;
+}
+// Self-check: the smallest thing that fails if parsing breaks.
+// Run with: node -e "import('./dist/contribution-parsing.js').then(m=>console.log(m.parseSkillFile('---\nname: x\ntoolNames:\n  - a\n---\nhi', '/s/x/SKILL.md').name))"
+//# sourceMappingURL=contribution-parsing.js.map

package/dist/contributions.d.ts

@@ -1,13 +1,14 @@
-import type { AgentDefinition, AuthMethod, CommandDefinition, CompactionStrategy, ContextProvider, CredentialResolver, InputBuilder, PromptBuilder, ProviderPackage, ProviderRequestPolicy, ResourceLoader, RetryPolicy, SettingsProvider, Skill, StoreFactory, SystemPromptContribution, ToolDefinition } from "./contracts.js";
+import type { AgentDefinition, AuthMethod, CommandDefinition, CompactionStrategy, ContextProvider, CredentialResolver, DiscoveredContribution, InputBuilder, InstructionInjector, PromptBuilder, ProviderPackage, ProviderRequestPolicy, ResourceLoader, RetryPolicy, SettingsProvider, Skill, StoreFactory, SystemPromptContribution, ToolDefinition } from "./contracts.js";
 import { type ModelRegistry } from "./models.js";
 import { type ProviderRegistry } from "./providers.js";
+import { type DuplicateRegistrationOptions } from "./registry-options.js";
 export interface ContributionRegistry<T> {
     register(key: string, contribution: T): void;
     get(key: string): T | undefined;
     resolve(key: string): T;
     list(): readonly T[];
 }
-export interface ContributionRegistryOptions {
+export interface ContributionRegistryOptions extends DuplicateRegistrationOptions {
     readonly label?: string;
 }
 export declare function createContributionRegistry<T>(options?: ContributionRegistryOptions): ContributionRegistry<T>;
@@ -31,5 +32,14 @@ export interface ContributionRegistries {
     readonly authMethods: ContributionRegistry<AuthMethod>;
     readonly providerRequestPolicies: ContributionRegistry<ProviderRequestPolicy>;
     readonly systemPromptContributions: ContributionRegistry<SystemPromptContribution>;
+    readonly instructionInjectors: ContributionRegistry<InstructionInjector>;
 }
-export declare function createContributionRegistries(): ContributionRegistries;
+export interface ContributionRegistriesOptions extends DuplicateRegistrationOptions {
+}
+export declare function createContributionRegistries(options?: ContributionRegistriesOptions): ContributionRegistries;
+/** Register discovered contributions into the given registries. Inert: skill
+ *  kinds register a fully realized {@link Skill}; tool/context/instructions
+ *  kinds register **descriptor-only** entries whose executable behavior is
+ *  host-owned. Performs NO `import()`. Last-write-wins per `(kind, name)`
+ *  (workspace discovery already won the merge; calling twice is idempotent). */
+export declare function registerDiscoveredContributions(registries: ContributionRegistries, contributions: readonly DiscoveredContribution[]): void;

package/dist/contributions.js

@@ -1,10 +1,12 @@
 import { createModelRegistry } from "./models.js";
 import { createProviderRegistry } from "./providers.js";
+import { assertCanRegister } from "./registry-options.js";
 export function createContributionRegistry(options = {}) {
     const label = options.label ?? "contribution";
     const byKey = new Map();
     return {
         register(key, contribution) {
+            assertCanRegister(byKey, key, label, key, options.duplicate);
             byKey.set(key, contribution);
         },
         get(key) {
@@ -21,27 +23,101 @@ export function createContributionRegistry(options = {}) {
         },
     };
 }
-export function createContributionRegistries() {
+export function createContributionRegistries(options = {}) {
+    const registryOptions = (label) => ({ label, duplicate: options.duplicate });
     return {
-        providers: createProviderRegistry(),
-        models: createModelRegistry(),
-        tools: createContributionRegistry({ label: "tool" }),
-        contextProviders: createContributionRegistry({ label: "context provider" }),
-        skills: createContributionRegistry({ label: "skill" }),
-        commands: createContributionRegistry({ label: "command" }),
-        agents: createContributionRegistry({ label: "agent" }),
-        inputBuilders: createContributionRegistry({ label: "input builder" }),
-        promptBuilders: createContributionRegistry({ label: "prompt builder" }),
-        compactionStrategies: createContributionRegistry({ label: "compaction strategy" }),
-        retryPolicies: createContributionRegistry({ label: "retry policy" }),
-        storeFactories: createContributionRegistry({ label: "store factory" }),
-        resourceLoaders: createContributionRegistry({ label: "resource loader" }),
-        settingsProviders: createContributionRegistry({ label: "settings provider" }),
-        credentialResolvers: createContributionRegistry({ label: "credential resolver" }),
-        providerPackages: createContributionRegistry({ label: "provider package" }),
-        authMethods: createContributionRegistry({ label: "auth method" }),
-        providerRequestPolicies: createContributionRegistry({ label: "provider request policy" }),
-        systemPromptContributions: createContributionRegistry({ label: "system prompt contribution" }),
+        providers: createProviderRegistry([], options),
+        models: createModelRegistry([], options),
+        tools: createContributionRegistry(registryOptions("tool")),
+        contextProviders: createContributionRegistry(registryOptions("context provider")),
+        skills: createContributionRegistry(registryOptions("skill")),
+        commands: createContributionRegistry(registryOptions("command")),
+        agents: createContributionRegistry(registryOptions("agent")),
+        inputBuilders: createContributionRegistry(registryOptions("input builder")),
+        promptBuilders: createContributionRegistry(registryOptions("prompt builder")),
+        compactionStrategies: createContributionRegistry(registryOptions("compaction strategy")),
+        retryPolicies: createContributionRegistry(registryOptions("retry policy")),
+        storeFactories: createContributionRegistry(registryOptions("store factory")),
+        resourceLoaders: createContributionRegistry(registryOptions("resource loader")),
+        settingsProviders: createContributionRegistry(registryOptions("settings provider")),
+        credentialResolvers: createContributionRegistry(registryOptions("credential resolver")),
+        providerPackages: createContributionRegistry(registryOptions("provider package")),
+        authMethods: createContributionRegistry(registryOptions("auth method")),
+        providerRequestPolicies: createContributionRegistry(registryOptions("provider request policy")),
+        systemPromptContributions: createContributionRegistry(registryOptions("system prompt contribution")),
+        instructionInjectors: createContributionRegistry(registryOptions("instruction injector")),
+    };
+}
+/** Register discovered contributions into the given registries. Inert: skill
+ *  kinds register a fully realized {@link Skill}; tool/context/instructions
+ *  kinds register **descriptor-only** entries whose executable behavior is
+ *  host-owned. Performs NO `import()`. Last-write-wins per `(kind, name)`
+ *  (workspace discovery already won the merge; calling twice is idempotent). */
+export function registerDiscoveredContributions(registries, contributions) {
+    for (const contribution of contributions) {
+        switch (contribution.kind) {
+            case "skill": {
+                if (contribution.skill)
+                    registries.skills.register(contribution.skill.name, contribution.skill);
+                break;
+            }
+            case "tool": {
+                registries.tools.register(contribution.name, descriptorTool(contribution));
+                break;
+            }
+            case "context": {
+                registries.contextProviders.register(contribution.name, descriptorContextProvider(contribution));
+                break;
+            }
+            case "instructions": {
+                registries.systemPromptContributions.register(contribution.name, descriptorInstructions(contribution));
+                break;
+            }
+        }
+    }
+}
+function discoverMetadata(contribution) {
+    const decl = contribution.declaration;
+    return {
+        discovered: true,
+        origin: contribution.origin,
+        path: contribution.path,
+        ...(decl?.module ? { module: decl.module } : {}),
+        ...(decl?.exportName ? { exportName: decl.exportName } : {}),
+        ...(decl?.resource ? { resource: decl.resource } : {}),
+    };
+}
+// ponytail: descriptor-only tool — no import(), no execution. Host owns resolving declaration.module.
+// ToolDefinition has no metadata slot; discovery provenance rides on the DiscoveredContribution envelope.
+function descriptorTool(contribution) {
+    const name = contribution.name;
+    return {
+        name,
+        description: `Discovered tool ${name}; host-owned execution`,
+        execute: () => {
+            throw new Error(`Discovered tool ${name} requires host execution (declaration.module not loaded)`);
+        },
+    };
+}
+function descriptorContextProvider(contribution) {
+    const name = contribution.name;
+    return {
+        name,
+        resolve: () => {
+            throw new Error(`Discovered context provider ${name} requires host execution (declaration.module not loaded)`);
+        },
+        // ponytail: ContextProvider has no metadata field; discovery provenance rides on declaration.resource/module via the DiscoveredContribution envelope.
+    };
+}
+// ponytail: core is fs-free; cannot read declaration.resource here. text is empty until the host
+// lifts the resource into actual prompt text (Phase 30 instruction injection).
+function descriptorInstructions(contribution) {
+    return {
+        id: contribution.name,
+        source: "package",
+        mode: "append",
+        text: "",
+        metadata: discoverMetadata(contribution),
     };
 }
 //# sourceMappingURL=contributions.js.map

package/dist/extensions.js

@@ -108,6 +108,9 @@ export function createExtensionKernel(options = {}) {
         registerSystemPromptContribution(contribution) {
             registries.systemPromptContributions.register(systemPromptContributionKey(contribution), contribution);
         },
+        registerInstructionInjector(injector) {
+            registries.instructionInjectors.register(injector.name, injector);
+        },
     };
     return {
         registries,

package/dist/index.d.ts

@@ -1,13 +1,18 @@
 export type * from "./contracts.js";
+export { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, isSessionAppendConflict } from "./contracts.js";
 export { createAgent, createAgentSession } from "./agents.js";
+export { applyCacheControl, cacheHitRate, cacheSavings, cacheUsageReport, mapCacheRetention, sanitizeCacheKey } from "./cache-helpers.js";
+export type { ApplyCacheControlOptions, CacheControlledContentBlock, CacheControlledMessage, CacheControlValue, CacheUsageReport } from "./cache-helpers.js";
+export { resolveAgentDefinition } from "./agent-definitions.js";
+export { parseSkillFile, parseAgentFile } from "./contribution-parsing.js";
 export { assertJsonObject, isJsonObject, loadConfigLayers, mergeConfigLayers } from "./config.js";
 export type { ConfigLayer, ConfigLoadContext, ConfigProvider } from "./config.js";
 export { createDefaultCompactionStrategy, isCompactionEntryData } from "./compaction.js";
 export type { DefaultCompactionStrategyOptions } from "./compaction.js";
 export { createDefaultRetryPolicy, isTransientErrorInfo, waitForRetry } from "./retry.js";
 export type { DefaultRetryPolicyOptions } from "./retry.js";
-export { createContributionRegistries, createContributionRegistry } from "./contributions.js";
-export type { ContributionRegistries, ContributionRegistry, ContributionRegistryOptions } from "./contributions.js";
+export { createContributionRegistries, createContributionRegistry, registerDiscoveredContributions } from "./contributions.js";
+export type { ContributionRegistries, ContributionRegistriesOptions, ContributionRegistry, ContributionRegistryOptions } from "./contributions.js";
 export { createChainedCredentialResolver, createEnvCredentialResolver, createExplicitCredentialResolver, createMemoryCredentialStore, refreshOAuthCredential, resolveCredentialValue } from "./credentials.js";
 export { createExtensionEventBus, createExtensionKernel } from "./extensions.js";
 export type { ExtensionErrorPolicy, ExtensionEventBus, ExtensionEventHandler, ExtensionKernel, ExtensionKernelOptions } from "./extensions.js";
@@ -18,7 +23,7 @@ export { createProviderRequestPolicyChain, createSessionCachePolicy, mergeProvid
 export type { SessionCachePolicyOptions } from "./provider-request-policy.js";
 export { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
 export type { ComposeSystemPromptOptions } from "./system-prompts.js";
-export type { ModelRegistry } from "./models.js";
+export type { ModelRegistry, ModelRegistryOptions } from "./models.js";
 export { definePrismManifest, parsePrismManifest } from "./manifests.js";
 export type { ManifestContributionDeclaration, ManifestContributionKind, ManifestResourceDeclaration, PrismManifest } from "./manifests.js";
 export { loadJsonResource, loadManifestResource, loadTextResource } from "./resources.js";
@@ -32,16 +37,21 @@ export { createMemorySessionStore, createSessionEntry, getSessionBranchEntries,
 export type { CreateSessionEntryOptions, SessionBranch, SessionBranchOptions, SessionContextSnapshot } from "./session-stores.js";
 export type { MockProviderOptions } from "./mock-provider.js";
 export { providerContentDelta, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, } from "./provider-events.js";
-export { createProviderRegistry } from "./providers.js";
-export type { ProviderRegistry } from "./providers.js";
-export { createSecretRedactor, errorToErrorInfo, redactAgentEvent, redactMessage, redactProviderRequest, redactSecrets, redactSessionEntry } from "./redaction.js";
+export type { ProviderResolver } from "./contracts.js";
+export { createProviderRegistry, createProviderResolver } from "./providers.js";
+export type { ProviderRegistry, ProviderRegistryOptions } from "./providers.js";
+export { createSecretRedactor, errorToErrorInfo, redactAgentEvent, redactMessage, redactProviderRequest, redactRunLedgerRecord, redactSecrets, redactSessionEntry } from "./redaction.js";
 export type { SecretRedactor } from "./redaction.js";
 export { assertPermission, assertTrusted, checkPermission, createStaticPermissionPolicy, createStaticTrustPolicy, denialToErrorInfo, isTrusted, PermissionDeniedError, TrustDeniedError } from "./security.js";
 export type { PermissionDecision, PermissionPolicy, PermissionRequest, TrustDecision, TrustPolicy, TrustRequest } from "./security.js";
 export { createSkillRegistry, resolveActiveSkills } from "./skills.js";
-export type { ResolveActiveSkillsOptions } from "./skills.js";
+export type { ResolveActiveSkillsOptions, SkillRegistryOptions } from "./skills.js";
+export { resolveInstructionInjectors, runInstructionInjectors } from "./instruction-injection.js";
+export type { ResolveInstructionInjectorsOptions } from "./instruction-injection.js";
 export { createToolRegistry, dispatchToolCall, filterTools } from "./tools.js";
-export type { DispatchToolCallOptions, ToolFilter, ToolFilterInput, ToolValidator } from "./tools.js";
+export type { DispatchToolCallOptions, ToolFilter, ToolFilterInput, ToolRegistryOptions, ToolValidator } from "./tools.js";
+export type { DuplicateRegistrationOptions, DuplicateRegistrationPolicy } from "./registry-options.js";
+export { generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, singleShotLoop } from "./agent-loops.js";
 export declare const name = "prism";
-export declare const version = "0.0.1";
+export declare const version = "0.0.2";
 export declare const description = "Agent harness for AI providers, agents, sessions, and tools.";

package/dist/index.js

@@ -1,8 +1,12 @@
+export { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, isSessionAppendConflict } from "./contracts.js";
 export { createAgent, createAgentSession } from "./agents.js";
+export { applyCacheControl, cacheHitRate, cacheSavings, cacheUsageReport, mapCacheRetention, sanitizeCacheKey } from "./cache-helpers.js";
+export { resolveAgentDefinition } from "./agent-definitions.js";
+export { parseSkillFile, parseAgentFile } from "./contribution-parsing.js";
 export { assertJsonObject, isJsonObject, loadConfigLayers, mergeConfigLayers } from "./config.js";
 export { createDefaultCompactionStrategy, isCompactionEntryData } from "./compaction.js";
 export { createDefaultRetryPolicy, isTransientErrorInfo, waitForRetry } from "./retry.js";
-export { createContributionRegistries, createContributionRegistry } from "./contributions.js";
+export { createContributionRegistries, createContributionRegistry, registerDiscoveredContributions } from "./contributions.js";
 export { createChainedCredentialResolver, createEnvCredentialResolver, createExplicitCredentialResolver, createMemoryCredentialStore, refreshOAuthCredential, resolveCredentialValue } from "./credentials.js";
 export { createExtensionEventBus, createExtensionKernel } from "./extensions.js";
 export { createModelRegistry } from "./models.js";
@@ -17,12 +21,14 @@ export { assembleProviderInput, createDefaultInputBuilder, createDefaultPromptBu
 export { createMockProvider } from "./mock-provider.js";
 export { createMemorySessionStore, createSessionEntry, getSessionBranchEntries, listSessionBranches, rebuildSessionContext } from "./session-stores.js";
 export { providerContentDelta, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, } from "./provider-events.js";
-export { createProviderRegistry } from "./providers.js";
-export { createSecretRedactor, errorToErrorInfo, redactAgentEvent, redactMessage, redactProviderRequest, redactSecrets, redactSessionEntry } from "./redaction.js";
+export { createProviderRegistry, createProviderResolver } from "./providers.js";
+export { createSecretRedactor, errorToErrorInfo, redactAgentEvent, redactMessage, redactProviderRequest, redactRunLedgerRecord, redactSecrets, redactSessionEntry } from "./redaction.js";
 export { assertPermission, assertTrusted, checkPermission, createStaticPermissionPolicy, createStaticTrustPolicy, denialToErrorInfo, isTrusted, PermissionDeniedError, TrustDeniedError } from "./security.js";
 export { createSkillRegistry, resolveActiveSkills } from "./skills.js";
+export { resolveInstructionInjectors, runInstructionInjectors } from "./instruction-injection.js";
 export { createToolRegistry, dispatchToolCall, filterTools } from "./tools.js";
+export { generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, singleShotLoop } from "./agent-loops.js";
 export const name = "prism";
-export const version = "0.0.1";
+export const version = "0.0.2";
 export const description = "Agent harness for AI providers, agents, sessions, and tools.";
 //# sourceMappingURL=index.js.map

package/dist/input.d.ts

@@ -1,5 +1,6 @@
-import type { ContentBlock, ContextBlock, ContextProvider, ContextResolutionContext, InputBuilder, InputBuildContext, JsonObject, Message, ModelConfig, PromptBuilder, PromptBuildRequest, ProviderRequest, ProviderRequestOptions, ResourceLoader, Skill, ToolDefinition, ToolResult } from "./contracts.js";
+import type { ContentBlock, ContextBlock, ContextProvider, ContextResolutionContext, InputBuilder, InstructionInjector, InputBuildContext, JsonObject, Message, ModelConfig, PromptBuilder, PromptBuildRequest, ProviderRequest, ProviderRequestOptions, ResourceLoader, Skill, ToolDefinition, ToolResult } from "./contracts.js";
 import type { MiddlewareRegistry } from "./middleware.js";
+import type { SecretRedactor } from "./redaction.js";
 export type AgentInput = string | Message | readonly Message[];
 export interface PromptInstruction {
     readonly text: string;
@@ -25,6 +26,8 @@ export interface DefaultInputBuildContext extends InputBuildContext {
     readonly resourceLoader?: ResourceLoader;
     readonly toolResults?: readonly ToolResult[];
     readonly middleware?: MiddlewareRegistry;
+    readonly instructionInjectors?: readonly InstructionInjector[];
+    readonly turn?: number;
 }
 export interface DefaultInputBuilder extends InputBuilder {
     build(input: AgentInput, context?: DefaultInputBuildContext): Promise<readonly Message[]>;
@@ -33,6 +36,7 @@ export interface ResolveContextOptions extends Omit<ContextResolutionContext, "m
     readonly messages: readonly Message[];
     readonly providers?: readonly ContextProvider[];
     readonly middleware?: MiddlewareRegistry;
+    readonly injectedBlocks?: readonly ContextBlock[];
 }
 export interface DefaultPromptBuilder extends PromptBuilder {
     build(request: PromptBuildRequest): Promise<readonly Message[]>;
@@ -42,6 +46,7 @@ export interface PromptTemplateOptions {
 }
 export interface AssembleProviderInputOptions extends DefaultInputBuildContext {
     readonly model: ModelConfig;
+    readonly redactor?: SecretRedactor;
     readonly input: AgentInput;
     readonly inputBuilder?: InputBuilder;
     readonly contextProviders?: readonly ContextProvider[];
@@ -55,3 +60,4 @@ export declare function resolveContextProviders(options: ResolveContextOptions):
 export declare function createDefaultPromptBuilder(): DefaultPromptBuilder;
 export declare function renderPromptTemplate(template: string, variables: JsonObject, options?: PromptTemplateOptions): string;
 export declare function assembleProviderInput(options: AssembleProviderInputOptions): Promise<ProviderRequest>;
+export declare function inputMessages(input: AgentInput): Message[];

package/dist/input.js

@@ -1,17 +1,24 @@
+import { redactMessage } from "./redaction.js";
 import { loadTextResource } from "./resources.js";
+import { composeSystemPrompt } from "./system-prompts.js";
+import { runInstructionInjectors } from "./instruction-injection.js";
 export function createDefaultInputBuilder() {
     return {
         name: "default-input",
         async build(input, context = {}) {
-            const messages = [];
-            messages.push(...instructionMessages(context.systemInstructions, "System instruction"));
-            messages.push(...instructionMessages(context.developerInstructions, "Developer instruction"));
-            messages.push(...customInstructionMessages(context.instructions));
-            messages.push(...summaryMessages(context.summaries));
-            messages.push(...(context.history ?? []));
-            messages.push(...inputMessages(input));
-            messages.push(...await attachmentMessages(context));
-            messages.push(...toolResultMessages(context.toolResults));
+            const groups = {
+                instructions: [
+                    ...instructionMessages(context.systemInstructions, "System instruction"),
+                    ...instructionMessages(context.developerInstructions, "Developer instruction"),
+                    ...customInstructionMessages(context.instructions),
+                ],
+                summaries: summaryMessages(context.summaries),
+                history: [...(context.history ?? [])],
+                input: inputMessages(input),
+                attachments: await attachmentMessages(context),
+                toolResults: toolResultMessages(context.toolResults),
+            };
+            const messages = flattenInputGroups(groups, context.inputLayout ?? "legacy");
             return context.middleware ? context.middleware.run("input_assembly", messages) : messages;
         },
     };
@@ -28,6 +35,9 @@ export async function resolveContextProviders(options) {
             signal: options.signal,
         }));
     }
+    // ponytail: injector blocks after host+skill provider blocks (split by origin if per-block ordering matters).
+    if (options.injectedBlocks)
+        blocks.push(...options.injectedBlocks);
     return options.middleware ? options.middleware.run("context", blocks) : blocks;
 }
 export function createDefaultPromptBuilder() {
@@ -61,10 +71,31 @@ export async function assembleProviderInput(options) {
         metadata: options.metadata,
         signal: options.signal,
     };
-    const messages = await inputBuilder.build(options.input, { ...options, ...baseContext });
+    // ponytail: Phase 30 — run injectors once per turn inside the assembler so when/predicate/turn
+    // filter against loop-local turn. Instructions layer via composeSystemPrompt (no parallel prompt
+    // code); contextBlocks merge via resolveContextProviders (middleware still runs).
+    const turn = options.turn ?? 1;
+    const injectorContribs = options.instructionInjectors?.length
+        ? runInstructionInjectors(options.instructionInjectors, {
+            sessionId: options.sessionId ?? "",
+            runId: options.runId ?? "",
+            turn,
+            // Runtime history is already redacted; input is redacted here before injector code sees it.
+            input: inputMessages(options.input).map((message) => redactMessage(message, options.redactor)),
+            history: options.history ?? [],
+            metadata: options.metadata ?? {},
+            signal: options.signal ?? new AbortController().signal,
+        })
+        : { instructions: [], contextBlocks: [] };
+    const systemInstructions = injectorContribs.instructions.length
+        ? composeSystemPrompt(injectorContribs.instructions, { base: options.systemInstructions })
+        : options.systemInstructions;
+    const buildContext = { ...options, ...baseContext, systemInstructions };
+    const messages = await inputBuilder.build(options.input, buildContext);
     const context = await resolveContextProviders({
         providers: options.contextProviders,
         messages,
+        injectedBlocks: injectorContribs.contextBlocks.length ? injectorContribs.contextBlocks : undefined,
         middleware: options.middleware,
         ...baseContext,
     });
@@ -97,7 +128,15 @@ export async function assembleProviderInput(options) {
         signal: options.signal,
     };
 }
-function inputMessages(input) {
+function flattenInputGroups(groups, layout) {
+    switch (layout) {
+        case "cache_aware":
+            return [...groups.instructions, ...groups.attachments, ...groups.summaries, ...groups.history, ...groups.toolResults, ...groups.input];
+        case "legacy":
+            return [...groups.instructions, ...groups.summaries, ...groups.history, ...groups.input, ...groups.attachments, ...groups.toolResults];
+    }
+}
+export function inputMessages(input) {
     if (typeof input === "string")
         return [textMessage("user", input)];
     if ("role" in input)
@@ -191,6 +230,8 @@ function blockText(block) {
             return JSON.stringify(part.result ?? part.error ?? null);
         if (part.type === "tool_call")
             return `${part.name}(${JSON.stringify(part.arguments)})`;
+        if (part.type === "tool_call_delta")
+            return `${part.name ?? "tool"}(${part.argumentsText ?? ""})`;
         return part.url ?? part.mimeType ?? "[image]";
     }).join("\n");
 }

package/dist/instruction-injection.d.ts

@@ -0,0 +1,28 @@
+import type { ContributionRegistry } from "./contributions.js";
+import type { ContextBlock, InstructionContext, InstructionInjector, SystemPromptContribution } from "./contracts.js";
+/** Run each selected injector against `ctx`, returning the matching contributions as
+ *  `package`-source `SystemPromptContribution[]` (for `composeSystemPrompt`) and
+ *  `ContextBlock[]` (for the context merge). Aborts on `ctx.signal`. Non-matching
+ *  injectors contribute nothing; only `instructions`/`contextBlocks` are honored —
+ *  injectors cannot register tools, skills, or permissions. */
+export declare function runInstructionInjectors(injectors: readonly InstructionInjector[], ctx: InstructionContext): {
+    readonly instructions: readonly SystemPromptContribution[];
+    readonly contextBlocks: readonly ContextBlock[];
+};
+export interface ResolveInstructionInjectorsOptions {
+    /** Explicit injector list (e.g. from AgentConfig/RunOptions). Returned as-is when `names` is absent. */
+    readonly configured?: readonly InstructionInjector[];
+    /** Registry to resolve `names` against. */
+    readonly registry?: ContributionRegistry<InstructionInjector>;
+    /** Names resolved against `registry` (fail closed on miss); ignored when `configured` is set. */
+    readonly names?: readonly string[];
+}
+/**
+ * Resolve the effective injector list for a run. Mirrors {@link resolveActiveSkills}
+ * fail-closed name resolution. When `configured` is provided it wins (RunOptions
+ * supplies an explicit list); otherwise names are resolved against `registry`.
+ * An unknown name throws `Unknown instruction injector: <name>`.
+ *
+ * ponytail: no toolNames enforcement — injectors grant no tools (unlike skills).
+ */
+export declare function resolveInstructionInjectors(options: ResolveInstructionInjectorsOptions): readonly InstructionInjector[];