agentplane 0.3.8 → 0.3.10

package/dist/runtime/incidents/resolve.js

@@ -0,0 +1,437 @@
+const INCIDENTS_HEADER = [
+    "# Policy Incidents Log",
+    "",
+    "This is the single file for incident-derived and situational policy rules.",
+].join("\n");
+function normalizeLines(text) {
+    return text.replaceAll("\r\n", "\n").split("\n");
+}
+function normalizeKey(key) {
+    return key
+        .trim()
+        .toLowerCase()
+        .replaceAll(/[\s_-]+/g, "");
+}
+function normalizeSearchText(text) {
+    return text
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9]+/gi, " ")
+        .trim();
+}
+function tokenize(text) {
+    const normalized = normalizeSearchText(text);
+    if (!normalized)
+        return [];
+    return normalized
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 3);
+}
+function dedupeCaseInsensitive(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        const trimmed = String(value ?? "").trim();
+        if (!trimmed)
+            continue;
+        const key = trimmed.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(trimmed);
+    }
+    return out;
+}
+function parseCsvList(value) {
+    if (!value)
+        return [];
+    return dedupeCaseInsensitive(value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean));
+}
+function parseBoolean(value) {
+    const normalized = String(value ?? "")
+        .trim()
+        .toLowerCase();
+    return normalized === "true" || normalized === "yes" || normalized === "y" || normalized === "1";
+}
+function parseEntryState(value) {
+    return value === "open" || value === "promoted" ? value : "stabilized";
+}
+function appendFieldValue(record, key, value, joiner = " ") {
+    if (!record[key]) {
+        record[key] = value.trim();
+        return;
+    }
+    record[key] = `${record[key]}${joiner}${value.trim()}`.trim();
+}
+function buildIncidentFingerprint(entry) {
+    return [
+        entry.sourceTask ?? "",
+        normalizeSearchText(entry.scope),
+        normalizeSearchText(entry.failure),
+        normalizeSearchText(entry.rule),
+    ].join("|");
+}
+function buildMatchTerms(opts) {
+    const scopeTokens = tokenize(opts.scope);
+    return dedupeCaseInsensitive([...opts.explicitMatch, ...opts.tags, ...scopeTokens]).slice(0, 12);
+}
+export function createIncidentRegistrySkeleton() {
+    return [
+        INCIDENTS_HEADER,
+        "",
+        "## Entry contract",
+        "",
+        "- Add entries append-only.",
+        "- Every entry MUST include: `id`, `date`, `scope`, `failure`, `rule`, `evidence`, `enforcement`, `state`.",
+        "- New machine-matched entries SHOULD also include: `tags`, `match`, `advice`, `source_task`, `fixability`.",
+        "- `rule` MUST be concrete and testable (`MUST` / `MUST NOT`).",
+        "- `fixability: external` means the issue cannot be removed by changing only repository code and should instead stay as reusable operational advice.",
+        "- `state` values: `open`, `stabilized`, `promoted`.",
+        "",
+        "## Entry template",
+        "",
+        "- id: `INC-YYYYMMDD-NN`",
+        "- date: `YYYY-MM-DD`",
+        "- scope: `<affected scope>`",
+        "- tags: `<comma-separated matching tags>`",
+        "- match: `<comma-separated lookup keywords>`",
+        "- failure: `<observed failure mode>`",
+        "- advice: `<reusable recovery or prevention guidance>`",
+        "- rule: `<new or refined MUST/MUST NOT>`",
+        "- evidence: `<task ids / logs / links>`",
+        "- enforcement: `<CI|test|lint|script|manual>`",
+        "- source_task: `<task id>`",
+        "- fixability: `<external>`",
+        "- state: `<open|stabilized|promoted>`",
+        "",
+        "## Entries",
+        "",
+    ].join("\n");
+}
+export function parseIncidentRegistry(text) {
+    const lines = normalizeLines(text);
+    const entries = [];
+    let inEntries = false;
+    let currentFields = null;
+    let currentLine = 0;
+    let currentKey = null;
+    const flush = () => {
+        if (!currentFields)
+            return;
+        const id = currentFields.id?.trim();
+        if (!id) {
+            currentFields = null;
+            currentKey = null;
+            currentLine = 0;
+            return;
+        }
+        const scope = currentFields.scope?.trim() ?? "";
+        const failure = currentFields.failure?.trim() ?? "";
+        const rule = currentFields.rule?.trim() ?? "";
+        const evidence = currentFields.evidence?.trim() ?? "";
+        const enforcement = currentFields.enforcement?.trim() ?? "manual";
+        entries.push({
+            id,
+            date: currentFields.date?.trim() ?? "",
+            scope,
+            failure,
+            rule,
+            evidence,
+            enforcement,
+            state: parseEntryState(currentFields.state),
+            tags: parseCsvList(currentFields.tags),
+            match: parseCsvList(currentFields.match),
+            advice: currentFields.advice?.trim() || null,
+            sourceTask: currentFields.source_task?.trim() || null,
+            fixability: currentFields.fixability?.trim().toLowerCase() === "external" ? "external" : null,
+            rawFields: { ...currentFields },
+            line: currentLine,
+        });
+        currentFields = null;
+        currentKey = null;
+        currentLine = 0;
+    };
+    for (const [index, line] of lines.entries()) {
+        const trimmed = line.trim();
+        if (!inEntries) {
+            if (trimmed === "## Entries")
+                inEntries = true;
+            continue;
+        }
+        if (/^##\s+/.test(trimmed))
+            break;
+        const idMatch = /^- id:\s*(.+?)\s*$/.exec(trimmed);
+        if (idMatch) {
+            flush();
+            currentFields = { id: idMatch[1] ?? "" };
+            currentKey = "id";
+            currentLine = index + 1;
+            continue;
+        }
+        if (!currentFields)
+            continue;
+        const fieldMatch = /^\s{2}([a-z_]+):\s*(.*?)\s*$/.exec(line);
+        if (fieldMatch) {
+            currentKey = String(fieldMatch[1] ?? "").trim();
+            currentFields[currentKey] = fieldMatch[2] ?? "";
+            continue;
+        }
+        if (currentKey && /^\s{4,}\S/.test(line)) {
+            appendFieldValue(currentFields, currentKey, line.trim(), "\n");
+            continue;
+        }
+        if (!trimmed) {
+            flush();
+        }
+    }
+    flush();
+    return { entries };
+}
+export function formatIncidentRegistryEntry(entry) {
+    return [
+        `- id: ${entry.id}`,
+        `  date: ${entry.date}`,
+        `  scope: ${entry.scope}`,
+        ...(entry.tags.length > 0 ? [`  tags: ${entry.tags.join(", ")}`] : []),
+        ...(entry.match.length > 0 ? [`  match: ${entry.match.join(", ")}`] : []),
+        `  failure: ${entry.failure}`,
+        ...(entry.advice ? [`  advice: ${entry.advice}`] : []),
+        `  rule: ${entry.rule}`,
+        `  evidence: ${entry.evidence}`,
+        `  enforcement: ${entry.enforcement}`,
+        ...(entry.sourceTask ? [`  source_task: ${entry.sourceTask}`] : []),
+        ...(entry.fixability ? [`  fixability: ${entry.fixability}`] : []),
+        `  state: ${entry.state}`,
+    ].join("\n");
+}
+export function appendIncidentRegistryEntries(currentText, entries) {
+    if (entries.length === 0)
+        return currentText;
+    const base = currentText.trim().length > 0
+        ? currentText.trimEnd()
+        : createIncidentRegistrySkeleton().trimEnd();
+    const suffix = entries.map((entry) => formatIncidentRegistryEntry(entry)).join("\n\n");
+    return `${base}\n\n${suffix}\n`;
+}
+export function extractIncidentCandidatesFromFindings(findings) {
+    const lines = normalizeLines(findings);
+    const candidates = [];
+    let currentFields = null;
+    let currentLine = 0;
+    let currentKey = null;
+    const flush = () => {
+        if (!currentFields)
+            return;
+        const promotion = currentFields.promotion?.trim() ?? "";
+        if (promotion.toLowerCase() !== "incident-candidate") {
+            currentFields = null;
+            currentKey = null;
+            currentLine = 0;
+            return;
+        }
+        const observation = currentFields.observation?.trim() ?? "";
+        if (!observation) {
+            currentFields = null;
+            currentKey = null;
+            currentLine = 0;
+            return;
+        }
+        candidates.push({
+            observation,
+            impact: currentFields.impact?.trim() || null,
+            resolution: currentFields.resolution?.trim() || null,
+            promotion,
+            incidentScope: currentFields.incidentscope?.trim() || null,
+            incidentRule: currentFields.incidentrule?.trim() || null,
+            incidentAdvice: currentFields.incidentadvice?.trim() || null,
+            incidentTags: parseCsvList(currentFields.incidenttags),
+            incidentMatch: parseCsvList(currentFields.incidentmatch),
+            incidentExternal: parseBoolean(currentFields.incidentexternal),
+            line: currentLine,
+            rawFields: { ...currentFields },
+        });
+        currentFields = null;
+        currentKey = null;
+        currentLine = 0;
+    };
+    for (const [index, line] of lines.entries()) {
+        const observationMatch = /^\s*-\s+Observation:\s*(.*?)\s*$/.exec(line);
+        if (observationMatch) {
+            flush();
+            currentFields = { observation: observationMatch[1] ?? "" };
+            currentKey = "observation";
+            currentLine = index + 1;
+            continue;
+        }
+        if (!currentFields)
+            continue;
+        if (/^\s*-\s+/.test(line)) {
+            flush();
+            const nestedObservationMatch = /^\s*-\s+Observation:\s*(.*?)\s*$/.exec(line);
+            if (nestedObservationMatch) {
+                currentFields = { observation: nestedObservationMatch[1] ?? "" };
+                currentKey = "observation";
+                currentLine = index + 1;
+            }
+            continue;
+        }
+        const fieldMatch = /^\s{2,}([A-Za-z][A-Za-z0-9 _-]*):\s*(.*?)\s*$/.exec(line);
+        if (fieldMatch) {
+            currentKey = normalizeKey(fieldMatch[1] ?? "");
+            currentFields[currentKey] = fieldMatch[2] ?? "";
+            continue;
+        }
+        if (currentKey && /^\s{2,}\S/.test(line)) {
+            appendFieldValue(currentFields, currentKey, line.trim(), "\n");
+            continue;
+        }
+        if (!line.trim()) {
+            continue;
+        }
+        if (currentKey) {
+            appendFieldValue(currentFields, currentKey, line.trim());
+        }
+    }
+    flush();
+    return candidates;
+}
+function nextIncidentId(entries, now) {
+    const dateStamp = `${now.getUTCFullYear()}${String(now.getUTCMonth() + 1).padStart(2, "0")}${String(now.getUTCDate()).padStart(2, "0")}`;
+    const prefix = `INC-${dateStamp}-`;
+    let max = 0;
+    for (const entry of entries) {
+        if (!entry.id.startsWith(prefix))
+            continue;
+        const num = Number.parseInt(entry.id.slice(prefix.length), 10);
+        if (Number.isInteger(num) && num > max)
+            max = num;
+    }
+    return `${prefix}${String(max + 1).padStart(2, "0")}`;
+}
+function buildPromotionIssues(candidate) {
+    const missingFields = [];
+    if (!candidate.incidentExternal)
+        missingFields.push("IncidentExternal: true");
+    if (!candidate.incidentScope)
+        missingFields.push("IncidentScope");
+    if (!candidate.incidentRule)
+        missingFields.push("IncidentRule");
+    if (!candidate.incidentAdvice)
+        missingFields.push("IncidentAdvice");
+    return missingFields.length > 0 ? { candidate, missingFields } : null;
+}
+function buildIncidentRegistryEntry(opts) {
+    const date = opts.now.toISOString().slice(0, 10);
+    const tags = dedupeCaseInsensitive([
+        ...opts.candidate.incidentTags,
+        ...opts.task.tags.map((tag) => tag.trim()),
+    ]);
+    const match = buildMatchTerms({
+        scope: opts.candidate.incidentScope ?? opts.task.title,
+        tags,
+        explicitMatch: opts.candidate.incidentMatch,
+    });
+    return {
+        id: nextIncidentId(opts.existingEntries, opts.now),
+        date,
+        scope: opts.candidate.incidentScope ?? opts.task.title,
+        failure: opts.candidate.observation,
+        rule: opts.candidate.incidentRule ?? "",
+        evidence: `task ${opts.task.id}${opts.task.commitHash ? `; commit ${opts.task.commitHash.slice(0, 12)}` : ""}`,
+        enforcement: "manual",
+        state: "stabilized",
+        tags,
+        match,
+        advice: opts.candidate.incidentAdvice,
+        sourceTask: opts.task.id,
+        fixability: "external",
+        rawFields: {},
+        line: 0,
+    };
+}
+export function planIncidentCollection(opts) {
+    const candidates = extractIncidentCandidatesFromFindings(opts.findings);
+    const issues = [];
+    const promotable = [];
+    const duplicates = [];
+    const now = opts.now ?? new Date();
+    const seenFingerprints = new Set(opts.registry.entries.map((entry) => buildIncidentFingerprint(entry)));
+    for (const candidate of candidates) {
+        const issue = buildPromotionIssues(candidate);
+        if (issue) {
+            issues.push(issue);
+            continue;
+        }
+        const entry = buildIncidentRegistryEntry({
+            task: opts.task,
+            candidate,
+            now,
+            existingEntries: [...opts.registry.entries, ...promotable.map((item) => item.entry)],
+        });
+        const fingerprint = buildIncidentFingerprint(entry);
+        const draft = { candidate, entry, fingerprint };
+        if (seenFingerprints.has(fingerprint)) {
+            duplicates.push(draft);
+            continue;
+        }
+        seenFingerprints.add(fingerprint);
+        promotable.push(draft);
+    }
+    return { candidates, promotable, duplicates, issues };
+}
+export function buildIncidentAdviceQueryFromTask(opts) {
+    return {
+        taskId: opts.taskId,
+        title: opts.title,
+        description: opts.description,
+        scope: opts.scope ?? null,
+        tags: dedupeCaseInsensitive(opts.tags),
+    };
+}
+export function resolveIncidentAdviceMatches(opts) {
+    const limit = Math.max(1, opts.limit ?? 5);
+    const tagSet = new Set(opts.query.tags.map((tag) => tag.trim().toLowerCase()).filter(Boolean));
+    const haystack = [opts.query.title, opts.query.description, opts.query.scope ?? ""].join(" ");
+    const normalizedHaystack = normalizeSearchText(haystack);
+    const queryTokens = new Set([...tokenize(haystack), ...tagSet]);
+    const matches = [];
+    for (const entry of opts.registry.entries) {
+        if (entry.state === "open")
+            continue;
+        const matchedTags = entry.tags.filter((tag) => tagSet.has(tag.trim().toLowerCase()));
+        const matchedTerms = entry.match.filter((term) => queryTokens.has(term.trim().toLowerCase()) ||
+            normalizedHaystack.includes(normalizeSearchText(term)));
+        const normalizedScope = normalizeSearchText(entry.scope);
+        const scopeMatched = normalizedScope.length > 0 && normalizedHaystack.includes(normalizedScope);
+        const score = matchedTags.length * 5 + matchedTerms.length * 2 + (scopeMatched ? 3 : 0);
+        if (score <= 0)
+            continue;
+        matches.push({ entry, score, matchedTags, matchedTerms, scopeMatched });
+    }
+    matches.sort((left, right) => {
+        if (right.score !== left.score)
+            return right.score - left.score;
+        return right.entry.date.localeCompare(left.entry.date);
+    });
+    return matches.slice(0, limit);
+}
+export function renderIncidentAdvice(matches) {
+    if (matches.length === 0)
+        return "No matching incident advice.";
+    return matches
+        .map((match) => {
+        const lines = [
+            `- ${match.entry.id} | scope: ${match.entry.scope}`,
+            `  failure: ${match.entry.failure}`,
+            `  advice: ${match.entry.advice ?? match.entry.rule}`,
+            `  rule: ${match.entry.rule}`,
+        ];
+        if (match.entry.evidence)
+            lines.push(`  evidence: ${match.entry.evidence}`);
+        return lines.join("\n");
+    })
+        .join("\n");
+}

package/dist/runtime/incidents/types.d.ts

@@ -0,0 +1,72 @@
+export type IncidentRegistryEntryState = "open" | "stabilized" | "promoted";
+export type IncidentRegistryEntry = {
+    id: string;
+    date: string;
+    scope: string;
+    failure: string;
+    rule: string;
+    evidence: string;
+    enforcement: string;
+    state: IncidentRegistryEntryState;
+    tags: string[];
+    match: string[];
+    advice: string | null;
+    sourceTask: string | null;
+    fixability: "external" | null;
+    rawFields: Record<string, string>;
+    line: number;
+};
+export type IncidentRegistry = {
+    entries: IncidentRegistryEntry[];
+};
+export type IncidentFindingCandidate = {
+    observation: string;
+    impact: string | null;
+    resolution: string | null;
+    promotion: string;
+    incidentScope: string | null;
+    incidentRule: string | null;
+    incidentAdvice: string | null;
+    incidentTags: string[];
+    incidentMatch: string[];
+    incidentExternal: boolean;
+    line: number;
+    rawFields: Record<string, string>;
+};
+export type IncidentPromotionTaskContext = {
+    id: string;
+    title: string;
+    description: string;
+    tags: string[];
+    commitHash?: string | null;
+};
+export type IncidentPromotionDraft = {
+    candidate: IncidentFindingCandidate;
+    entry: IncidentRegistryEntry;
+    fingerprint: string;
+};
+export type IncidentPromotionIssue = {
+    candidate: IncidentFindingCandidate;
+    missingFields: string[];
+};
+export type IncidentCollectionPlan = {
+    candidates: IncidentFindingCandidate[];
+    promotable: IncidentPromotionDraft[];
+    duplicates: IncidentPromotionDraft[];
+    issues: IncidentPromotionIssue[];
+};
+export type IncidentAdviceQuery = {
+    taskId?: string;
+    title: string;
+    description: string;
+    scope?: string | null;
+    tags: string[];
+};
+export type IncidentAdviceMatch = {
+    entry: IncidentRegistryEntry;
+    score: number;
+    matchedTags: string[];
+    matchedTerms: string[];
+    scopeMatched: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/incidents/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/incidents/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,0BAA0B,GAAG,MAAM,GAAG,YAAY,GAAG,UAAU,CAAC;AAE5E,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,0BAA0B,CAAC;IAClC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,qBAAqB,EAAE,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,wBAAwB,CAAC;IACpC,KAAK,EAAE,qBAAqB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,wBAAwB,CAAC;IACpC,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,UAAU,EAAE,wBAAwB,EAAE,CAAC;IACvC,UAAU,EAAE,sBAAsB,EAAE,CAAC;IACrC,UAAU,EAAE,sBAAsB,EAAE,CAAC;IACrC,MAAM,EAAE,sBAAsB,EAAE,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,qBAAqB,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC"}

package/dist/runtime/incidents/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/protocol/index.d.ts

@@ -0,0 +1,3 @@
+export { AGENTPLANE_PROTOCOL_COMPATIBILITY, buildFrameworkExplainProtocolResult, buildFrameworkProtocolSurface, buildProtocolErrorResult, buildProtocolSuccessResult, } from "./resolve.js";
+export { AGENTPLANE_PROTOCOL_SCHEMA_VERSION, type AgentplaneProtocolBase, type AgentplaneProtocolCompatibility, type AgentplaneProtocolError, type AgentplaneProtocolErrorResult, type AgentplaneProtocolKind, type AgentplaneProtocolResult, type AgentplaneProtocolSchemaVersion, type AgentplaneProtocolStatus, type AgentplaneProtocolSuccessResult, type FrameworkExplainProtocolResult, type FrameworkProtocolSurface, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/protocol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/protocol/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,EACjC,mCAAmC,EACnC,6BAA6B,EAC7B,wBAAwB,EACxB,0BAA0B,GAC3B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,kCAAkC,EAClC,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACpC,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,+BAA+B,EACpC,KAAK,wBAAwB,EAC7B,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,wBAAwB,GAC9B,MAAM,YAAY,CAAC"}

package/dist/runtime/protocol/index.js

@@ -0,0 +1,2 @@
+export { AGENTPLANE_PROTOCOL_COMPATIBILITY, buildFrameworkExplainProtocolResult, buildFrameworkProtocolSurface, buildProtocolErrorResult, buildProtocolSuccessResult, } from "./resolve.js";
+export { AGENTPLANE_PROTOCOL_SCHEMA_VERSION, } from "./types.js";

package/dist/runtime/protocol/resolve.d.ts

@@ -0,0 +1,16 @@
+import type { FrameworkExplainPayload } from "../explain/index.js";
+import { type AgentplaneProtocolCompatibility, type AgentplaneProtocolError, type AgentplaneProtocolErrorResult, type AgentplaneProtocolKind, type AgentplaneProtocolSuccessResult, type FrameworkExplainProtocolResult, type FrameworkProtocolSurface } from "./types.js";
+export declare const AGENTPLANE_PROTOCOL_COMPATIBILITY: AgentplaneProtocolCompatibility;
+export declare function buildProtocolSuccessResult<TKind extends AgentplaneProtocolKind, TData>(opts: {
+    kind: TKind;
+    data: TData;
+}): AgentplaneProtocolSuccessResult<TKind, TData>;
+export declare function buildProtocolErrorResult<TKind extends AgentplaneProtocolKind>(opts: {
+    kind: TKind;
+    error: AgentplaneProtocolError;
+}): AgentplaneProtocolErrorResult<TKind>;
+export declare function buildFrameworkExplainProtocolResult(explain: FrameworkExplainPayload): FrameworkExplainProtocolResult;
+export declare function buildFrameworkProtocolSurface(opts: {
+    explain: FrameworkExplainPayload;
+}): FrameworkProtocolSurface;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/runtime/protocol/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../src/runtime/protocol/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEnE,OAAO,EAEL,KAAK,+BAA+B,EACpC,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,wBAAwB,EAC9B,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,iCAAiC,EAAE,+BAK/C,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,KAAK,SAAS,sBAAsB,EAAE,KAAK,EAAE,IAAI,EAAE;IAC5F,IAAI,EAAE,KAAK,CAAC;IACZ,IAAI,EAAE,KAAK,CAAC;CACb,GAAG,+BAA+B,CAAC,KAAK,EAAE,KAAK,CAAC,CAQhD;AAED,wBAAgB,wBAAwB,CAAC,KAAK,SAAS,sBAAsB,EAAE,IAAI,EAAE;IACnF,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,uBAAuB,CAAC;CAChC,GAAG,6BAA6B,CAAC,KAAK,CAAC,CAQvC;AAED,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,uBAAuB,GAC/B,8BAA8B,CAKhC;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,OAAO,EAAE,uBAAuB,CAAC;CAClC,GAAG,wBAAwB,CAI3B"}

package/dist/runtime/protocol/resolve.js

@@ -0,0 +1,36 @@
+import { AGENTPLANE_PROTOCOL_SCHEMA_VERSION, } from "./types.js";
+export const AGENTPLANE_PROTOCOL_COMPATIBILITY = {
+    strategy: "additive",
+    breaking_changes_require_schema_version: true,
+    additive_fields_allowed: true,
+    new_result_kinds_allowed: true,
+};
+export function buildProtocolSuccessResult(opts) {
+    return {
+        schema_version: AGENTPLANE_PROTOCOL_SCHEMA_VERSION,
+        kind: opts.kind,
+        status: "ok",
+        compatibility: structuredClone(AGENTPLANE_PROTOCOL_COMPATIBILITY),
+        data: structuredClone(opts.data),
+    };
+}
+export function buildProtocolErrorResult(opts) {
+    return {
+        schema_version: AGENTPLANE_PROTOCOL_SCHEMA_VERSION,
+        kind: opts.kind,
+        status: "error",
+        compatibility: structuredClone(AGENTPLANE_PROTOCOL_COMPATIBILITY),
+        error: structuredClone(opts.error),
+    };
+}
+export function buildFrameworkExplainProtocolResult(explain) {
+    return buildProtocolSuccessResult({
+        kind: "framework.explain",
+        data: explain,
+    });
+}
+export function buildFrameworkProtocolSurface(opts) {
+    return {
+        explain: buildFrameworkExplainProtocolResult(opts.explain),
+    };
+}

package/dist/runtime/protocol/types.d.ts

@@ -0,0 +1,36 @@
+import type { FrameworkExplainPayload } from "../explain/index.js";
+export declare const AGENTPLANE_PROTOCOL_SCHEMA_VERSION: 1;
+export type AgentplaneProtocolSchemaVersion = typeof AGENTPLANE_PROTOCOL_SCHEMA_VERSION;
+export type AgentplaneProtocolStatus = "ok" | "error";
+export type AgentplaneProtocolKind = string;
+export type AgentplaneProtocolCompatibility = {
+    strategy: "additive";
+    breaking_changes_require_schema_version: true;
+    additive_fields_allowed: true;
+    new_result_kinds_allowed: true;
+};
+export type AgentplaneProtocolBase<TKind extends AgentplaneProtocolKind> = {
+    schema_version: AgentplaneProtocolSchemaVersion;
+    kind: TKind;
+    compatibility: AgentplaneProtocolCompatibility;
+};
+export type AgentplaneProtocolSuccessResult<TKind extends AgentplaneProtocolKind, TData> = AgentplaneProtocolBase<TKind> & {
+    status: "ok";
+    data: TData;
+};
+export type AgentplaneProtocolError = {
+    code: string;
+    message: string;
+    retryable?: boolean;
+    details?: Record<string, unknown>;
+};
+export type AgentplaneProtocolErrorResult<TKind extends AgentplaneProtocolKind> = AgentplaneProtocolBase<TKind> & {
+    status: "error";
+    error: AgentplaneProtocolError;
+};
+export type AgentplaneProtocolResult<TKind extends AgentplaneProtocolKind, TData> = AgentplaneProtocolSuccessResult<TKind, TData> | AgentplaneProtocolErrorResult<TKind>;
+export type FrameworkExplainProtocolResult = AgentplaneProtocolSuccessResult<"framework.explain", FrameworkExplainPayload>;
+export type FrameworkProtocolSurface = {
+    explain: FrameworkExplainProtocolResult;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/protocol/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/protocol/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEnE,eAAO,MAAM,kCAAkC,EAAG,CAAU,CAAC;AAE7D,MAAM,MAAM,+BAA+B,GAAG,OAAO,kCAAkC,CAAC;AAExF,MAAM,MAAM,wBAAwB,GAAG,IAAI,GAAG,OAAO,CAAC;AAEtD,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC;AAE5C,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,EAAE,UAAU,CAAC;IACrB,uCAAuC,EAAE,IAAI,CAAC;IAC9C,uBAAuB,EAAE,IAAI,CAAC;IAC9B,wBAAwB,EAAE,IAAI,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,sBAAsB,CAAC,KAAK,SAAS,sBAAsB,IAAI;IACzE,cAAc,EAAE,+BAA+B,CAAC;IAChD,IAAI,EAAE,KAAK,CAAC;IACZ,aAAa,EAAE,+BAA+B,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,+BAA+B,CACzC,KAAK,SAAS,sBAAsB,EACpC,KAAK,IACH,sBAAsB,CAAC,KAAK,CAAC,GAAG;IAClC,MAAM,EAAE,IAAI,CAAC;IACb,IAAI,EAAE,KAAK,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,6BAA6B,CAAC,KAAK,SAAS,sBAAsB,IAC5E,sBAAsB,CAAC,KAAK,CAAC,GAAG;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,uBAAuB,CAAC;CAChC,CAAC;AAEJ,MAAM,MAAM,wBAAwB,CAAC,KAAK,SAAS,sBAAsB,EAAE,KAAK,IAC5E,+BAA+B,CAAC,KAAK,EAAE,KAAK,CAAC,GAC7C,6BAA6B,CAAC,KAAK,CAAC,CAAC;AAEzC,MAAM,MAAM,8BAA8B,GAAG,+BAA+B,CAC1E,mBAAmB,EACnB,uBAAuB,CACxB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,8BAA8B,CAAC;CACzC,CAAC"}

package/dist/runtime/protocol/types.js

@@ -0,0 +1 @@
+export const AGENTPLANE_PROTOCOL_SCHEMA_VERSION = 1;

package/dist/runtime/task-intake/index.d.ts

@@ -0,0 +1,3 @@
+export { createClarificationContract, createTaskGraphDraft, createTaskIntakeContext, createTaskIntakeRuntime, materializeTaskGraphDraft, } from "./resolve.js";
+export type { ClarificationContract, ClarificationQuestion, TaskGraphDependency, TaskGraphDraft, TaskGraphDraftTask, TaskIntakeContext, TaskIntakeInput, TaskIntakeInputKind, TaskIntakePrecedence, TaskIntakeRuntime, TaskIntakeSourceId, TaskIntakeSourceRef, TaskMaterializationEntry, TaskMaterializationPlan, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/task-intake/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/task-intake/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,EACpB,uBAAuB,EACvB,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,YAAY,CAAC"}

package/dist/runtime/task-intake/index.js

@@ -0,0 +1 @@
+export { createClarificationContract, createTaskGraphDraft, createTaskIntakeContext, createTaskIntakeRuntime, materializeTaskGraphDraft, } from "./resolve.js";