@blokjs/shared 2.1.0 → 2.2.1

package/dist/EvidenceContracts.js

@@ -0,0 +1,237 @@
+import { z } from "zod";
+import { INTERACTION_MAX_PAYLOAD_BYTES, INTERACTION_MAX_PAYLOAD_DEPTH, INTERACTION_MAX_PAYLOAD_ITEMS, INTERACTION_MAX_STRING_LENGTH, parseInteractionPayload, } from "./InteractionContracts.js";
+/** Version of the language-neutral evidence wire contract. */
+export const EVIDENCE_CONTRACT_VERSION = "1";
+/** Evidence uses the same bounded JSON value envelope as H1-01 answers. */
+export const EVIDENCE_MAX_RECORD_BYTES = INTERACTION_MAX_PAYLOAD_BYTES;
+export const EVIDENCE_MAX_PAYLOAD_DEPTH = INTERACTION_MAX_PAYLOAD_DEPTH;
+export const EVIDENCE_MAX_PAYLOAD_ITEMS = INTERACTION_MAX_PAYLOAD_ITEMS;
+export const EVIDENCE_MAX_STRING_LENGTH = INTERACTION_MAX_STRING_LENGTH;
+export const EVIDENCE_MAX_CHECKS = 32;
+export const EVIDENCE_MAX_REQUIREMENTS = 64;
+export const EVIDENCE_PRODUCER_KINDS = ["capability", "deterministic-step", "runner"];
+export const EVIDENCE_VERIFIER_KINDS = ["capability", "human", "runner"];
+export const EVIDENCE_VERIFICATION_STATUSES = ["verified", "failed", "unverified", "expired"];
+export const EVIDENCE_VERIFICATION_METHODS = [
+    "artifact-digest",
+    "schema-check",
+    "deterministic-check",
+    "capability-attestation",
+    "human-approval",
+];
+export const EVIDENCE_CHECK_OUTCOMES = ["passed", "failed"];
+export class EvidenceContractError extends Error {
+    issues;
+    constructor(issues) {
+        super(`Invalid evidence contract: ${issues.join("; ")}`);
+        this.name = "EvidenceContractError";
+        this.issues = [...issues];
+    }
+}
+const IDENTIFIER = /^[A-Za-z][A-Za-z0-9._:/-]{0,127}$/;
+const VERSION = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
+const CLAIM_CODE = /^[a-z][a-z0-9._:-]{0,127}$/;
+const DIGEST = /^(sha256):[0-9a-f]{64}$|^(sha512):[0-9a-f]{128}$/i;
+const PRODUCER_KIND = z.enum(EVIDENCE_PRODUCER_KINDS);
+const VERIFIER_KIND = z.enum(EVIDENCE_VERIFIER_KINDS);
+const VERIFICATION_STATUS = z.enum(EVIDENCE_VERIFICATION_STATUSES);
+const VERIFICATION_METHOD = z.enum(EVIDENCE_VERIFICATION_METHODS);
+const CHECK_OUTCOME = z.enum(EVIDENCE_CHECK_OUTCOMES);
+const identifier = z.string().min(1).max(128).regex(IDENTIFIER, "must be a bounded identifier");
+const version = z.string().min(1).max(128).regex(VERSION, "must be a bounded version");
+const claimCode = z.string().min(1).max(128).regex(CLAIM_CODE, "must be a machine-readable claim code");
+const timestamp = z.string().min(1).max(64);
+export const ArtifactIdentitySchema = z.object({
+    id: identifier,
+    kind: identifier,
+});
+export const ArtifactVersionIdentitySchema = z.object({
+    artifact: ArtifactIdentitySchema,
+    version,
+    digest: z
+        .string()
+        .max(140)
+        .regex(DIGEST, "must be a sha256: or sha512: digest with the complete hexadecimal length")
+        .transform((value) => value.toLowerCase()),
+});
+export const EvidenceProducerIdentitySchema = z.object({
+    kind: PRODUCER_KIND,
+    id: identifier,
+});
+const workflowIdentity = z.object({
+    name: identifier,
+    version: version.optional(),
+});
+const stepIdentity = z.object({
+    id: identifier,
+    index: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+    attempt: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
+});
+export const EvidenceTraceIdentitySchema = z.object({
+    runId: identifier,
+    nodeRunId: identifier.optional(),
+});
+export const EvidenceProvenanceIdentitySchema = z.object({
+    producer: EvidenceProducerIdentitySchema,
+    workflow: workflowIdentity,
+    step: stepIdentity,
+    trace: EvidenceTraceIdentitySchema,
+    interactionId: identifier.optional(),
+});
+export const EvidenceCheckSchema = z.object({
+    code: claimCode,
+    outcome: CHECK_OUTCOME,
+});
+export const EvidenceVerifierIdentitySchema = z.object({
+    kind: VERIFIER_KIND,
+    id: identifier,
+});
+export const EvidenceVerificationResultSchema = z
+    .object({
+    status: VERIFICATION_STATUS,
+    verifier: EvidenceVerifierIdentitySchema,
+    method: VERIFICATION_METHOD,
+    checkedAt: timestamp,
+    checks: z.array(EvidenceCheckSchema).min(1).max(EVIDENCE_MAX_CHECKS),
+    reasonCode: claimCode.optional(),
+})
+    .superRefine((value, context) => {
+    const failed = value.checks.some((check) => check.outcome === "failed");
+    if (value.status === "verified" && failed) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["checks"],
+            message: "verified results cannot contain failed checks",
+        });
+    }
+    if (value.status === "verified" && value.method === "human-approval" && value.verifier.kind !== "human") {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["verifier", "kind"],
+            message: "human-approval must be verified by a human",
+        });
+    }
+    if (value.status === "verified" &&
+        value.method === "capability-attestation" &&
+        value.verifier.kind !== "capability") {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["verifier", "kind"],
+            message: "capability-attestation must be verified by a capability",
+        });
+    }
+});
+export const EvidencePayloadSchema = z.unknown().transform((value, context) => {
+    try {
+        return parseInteractionPayload(value, "evidence payload");
+    }
+    catch (error) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: error instanceof Error ? error.message : "invalid payload",
+        });
+        return undefined;
+    }
+});
+export const EvidenceRecordSchema = z.object({
+    version: z.literal(EVIDENCE_CONTRACT_VERSION),
+    id: identifier,
+    kind: identifier,
+    claim: claimCode,
+    artifact: ArtifactVersionIdentitySchema,
+    provenance: EvidenceProvenanceIdentitySchema,
+    verification: EvidenceVerificationResultSchema,
+    observedAt: timestamp,
+    expiresAt: timestamp.optional(),
+    payload: EvidencePayloadSchema.optional(),
+});
+export const EvidenceRequirementSchema = z.object({
+    type: z.literal("evidence"),
+    id: identifier,
+    kind: identifier,
+    claim: claimCode.optional(),
+    artifactKind: identifier.optional(),
+    producers: z.array(PRODUCER_KIND).min(1).max(EVIDENCE_PRODUCER_KINDS.length),
+    verification: z.literal("verified"),
+});
+export const ApprovalRequirementSchema = z.object({
+    type: z.literal("approval"),
+    id: identifier,
+    interactionId: identifier,
+    status: z.literal("answered"),
+});
+export const CompletionRequirementSchema = z.discriminatedUnion("type", [
+    EvidenceRequirementSchema,
+    ApprovalRequirementSchema,
+]);
+export const CompletionContractSchema = z
+    .object({
+    version: z.literal(EVIDENCE_CONTRACT_VERSION),
+    id: identifier,
+    mode: z.enum(["all", "any"]),
+    requirements: z.array(CompletionRequirementSchema).min(1).max(EVIDENCE_MAX_REQUIREMENTS),
+})
+    .superRefine((value, context) => {
+    const ids = new Set();
+    for (const [index, requirement] of value.requirements.entries()) {
+        if (ids.has(requirement.id)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["requirements", index, "id"],
+                message: "requirement ids must be unique",
+            });
+        }
+        ids.add(requirement.id);
+    }
+});
+function byteLength(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+function parseSchema(schema, value, label) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        throw new EvidenceContractError(result.error.issues.map((issue) => `${label}${issue.path.length > 0 ? `.${issue.path.join(".")}` : ""} ${issue.message}`));
+    }
+    return result.data;
+}
+function assertRecordSize(value, label) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw new EvidenceContractError([`${label} must be JSON-serializable`]);
+    }
+    if (byteLength(serialized) > EVIDENCE_MAX_RECORD_BYTES) {
+        throw new EvidenceContractError([`${label} exceeds ${EVIDENCE_MAX_RECORD_BYTES} bytes`]);
+    }
+    return value;
+}
+/** Parse one bounded structured fact payload without accepting model prose as a record. */
+export function parseEvidencePayload(value) {
+    return parseSchema(EvidencePayloadSchema, value, "evidence payload");
+}
+/** Parse and normalize an evidence record at the trusted boundary. */
+export function parseEvidenceRecord(value) {
+    return assertRecordSize(parseSchema(EvidenceRecordSchema, value, "evidence record"), "evidence record");
+}
+/** Parse and normalize a completion contract at the workflow/load boundary. */
+export function parseCompletionContract(value) {
+    return assertRecordSize(parseSchema(CompletionContractSchema, value, "completion contract"), "completion contract");
+}
+export function serializeEvidenceRecord(value) {
+    return JSON.stringify(parseEvidenceRecord(value));
+}
+export function serializeCompletionContract(value) {
+    return JSON.stringify(parseCompletionContract(value));
+}
+/**
+ * A model message is descriptive context only. It cannot be adapted into a
+ * trusted record because the only accepted producer kinds are capability,
+ * deterministic-step, and runner.
+ */
+export function rejectModelEvidence(_value) {
+    throw new EvidenceContractError([
+        "model prose is not evidence; provide a capability- or deterministic-step-produced artifact and verification result",
+    ]);
+}

package/dist/GitCapabilityContracts.d.ts

@@ -0,0 +1,103 @@
+import { capabilityScope } from "./CapabilityContracts.js";
+import type { CapabilityOwner, CapabilityRequestContext, WorkspacePathRef } from "./CapabilityContracts.js";
+import type { PolicyEvaluationResult, PolicyRequest } from "./PolicyContracts.js";
+import type { RepositoryIdentity } from "./WorkflowBindingContracts.js";
+export declare const GIT_CAPABILITY_CONTRACT_VERSION: "1";
+export declare const GIT_MAX_CHANGED_FILES = 4096;
+export declare const GIT_MAX_BRANCH_NAME_LENGTH = 256;
+export declare const GIT_OPERATIONS: readonly ["repository.inspect", "worktree.create", "worktree.inspect", "worktree.diff", "worktree.cleanup"];
+export type GitOperation = (typeof GIT_OPERATIONS)[number];
+/** Deliberately not part of GitCapability: repository rewriting is denied. */
+export declare const GIT_DESTRUCTIVE_OPERATIONS: readonly ["repository.reset", "repository.clean", "repository.checkout", "repository.rebase", "repository.merge", "branch.delete", "worktree.force-cleanup"];
+export type GitDestructiveOperation = (typeof GIT_DESTRUCTIVE_OPERATIONS)[number];
+export type GitChangeStatus = "added" | "copied" | "deleted" | "modified" | "renamed" | "type-changed" | "untracked";
+export type GitWorktreeStatus = "active" | "cleanup-pending" | "cleaned";
+export interface GitRevisionIdentity {
+    readonly commit: string;
+    readonly ref?: string;
+}
+export interface GitDirtyState {
+    readonly status: "clean" | "dirty";
+    /** Hash of the status/content identity observed at the boundary. */
+    readonly fingerprint: string;
+    readonly changedPaths: readonly string[];
+}
+/** Repository facts captured before a task starts. */
+export interface GitRepositoryIdentity {
+    readonly repository: RepositoryIdentity;
+    readonly checkout: WorkspacePathRef;
+    readonly head: GitRevisionIdentity;
+    readonly dirty: GitDirtyState;
+    readonly owner: CapabilityOwner;
+}
+export interface GitWorktreeCreateRequest extends CapabilityRequestContext {
+    readonly policy: PolicyRequest;
+    readonly repository: GitRepositoryIdentity;
+    readonly base: GitRevisionIdentity;
+    readonly branch: string;
+    readonly path?: WorkspacePathRef;
+    /** Required so a dirty primary checkout can never be discarded implicitly. */
+    readonly preserveSourceChanges: true;
+}
+export interface GitWorktreeCleanupRequest extends GitCapabilityRequest {
+    /** Cleanup may not discard task changes; dirty worktrees stay recoverable. */
+    readonly preserveChanges: true;
+    readonly worktree: GitWorktreeIdentity;
+}
+export interface GitWorktreeIdentity {
+    readonly version: typeof GIT_CAPABILITY_CONTRACT_VERSION;
+    readonly id: string;
+    readonly repository: GitRepositoryIdentity;
+    readonly path: WorkspacePathRef;
+    readonly branch: string;
+    readonly base: GitRevisionIdentity;
+    readonly head: GitRevisionIdentity;
+    readonly sourceDirty: GitDirtyState;
+    readonly owner: CapabilityOwner;
+    readonly status: GitWorktreeStatus;
+    readonly createdAt: string;
+    readonly cleanedAt?: string;
+}
+export interface GitDiffFile {
+    readonly path: string;
+    readonly status: GitChangeStatus;
+    readonly previousPath?: string;
+    readonly contentHash: string;
+    readonly sizeBytes?: number;
+}
+export interface GitDiffEvidence {
+    readonly version: typeof GIT_CAPABILITY_CONTRACT_VERSION;
+    readonly repository: RepositoryIdentity;
+    readonly worktree: GitWorktreeIdentity;
+    readonly base: GitRevisionIdentity;
+    readonly head: GitRevisionIdentity;
+    readonly dirty: GitDirtyState;
+    readonly files: readonly GitDiffFile[];
+    /** Hash of the canonical diff/evidence record, not an unverified claim. */
+    readonly evidenceHash: string;
+    readonly capturedAt: string;
+}
+export interface GitCapabilityRequest extends CapabilityRequestContext {
+    readonly policy: PolicyRequest;
+    readonly operation: GitOperation;
+    readonly repository: GitRepositoryIdentity;
+    readonly worktree?: GitWorktreeIdentity;
+}
+export interface GitCapability {
+    inspectRepository(request: GitCapabilityRequest): Promise<GitRepositoryIdentity>;
+    createWorktree(request: GitWorktreeCreateRequest): Promise<GitWorktreeIdentity>;
+    inspectWorktree(request: GitCapabilityRequest): Promise<GitWorktreeIdentity>;
+    diff(request: GitCapabilityRequest): Promise<GitDiffEvidence>;
+    cleanup(request: GitWorktreeCleanupRequest): Promise<GitWorktreeIdentity>;
+}
+export declare function parseGitDirtyState(value: unknown): GitDirtyState;
+export declare function parseGitRepositoryIdentity(value: unknown): GitRepositoryIdentity;
+export declare function parseGitWorktreeIdentity(value: unknown): GitWorktreeIdentity;
+export declare function parseGitDiffEvidence(value: unknown): GitDiffEvidence;
+export declare function parseGitWorktreeCreateRequest(value: unknown): GitWorktreeCreateRequest;
+export declare function gitCapabilityScope(operation: GitOperation): ReturnType<typeof capabilityScope>;
+export declare function assertGitOperationAllowed(operation: string): asserts operation is GitOperation;
+export declare function parseGitOperation(value: unknown): GitOperation;
+export declare function assertGitPolicyAllowed(result: PolicyEvaluationResult): void;
+export declare function assertGitOwner(repository: GitRepositoryIdentity, owner: CapabilityOwner): void;
+export declare function workspacePathForGit(value: unknown): WorkspacePathRef;

package/dist/GitCapabilityContracts.js

@@ -0,0 +1,222 @@
+import { z } from "zod";
+import { AGENT_CAPABILITY_CONTRACT_VERSION, CAPABILITY_MAX_LIST_ITEMS, CapabilityContractError, CapabilityOwnerSchema, WorkspacePathRefSchema, assertAuthorized, assertOwned, capabilityScope, identifier, parseCapabilityOwner, parseWorkspacePathRef, timestamp, path as workspacePath, } from "./CapabilityContracts.js";
+export const GIT_CAPABILITY_CONTRACT_VERSION = AGENT_CAPABILITY_CONTRACT_VERSION;
+export const GIT_MAX_CHANGED_FILES = 4_096;
+export const GIT_MAX_BRANCH_NAME_LENGTH = 256;
+export const GIT_OPERATIONS = [
+    "repository.inspect",
+    "worktree.create",
+    "worktree.inspect",
+    "worktree.diff",
+    "worktree.cleanup",
+];
+/** Deliberately not part of GitCapability: repository rewriting is denied. */
+export const GIT_DESTRUCTIVE_OPERATIONS = [
+    "repository.reset",
+    "repository.clean",
+    "repository.checkout",
+    "repository.rebase",
+    "repository.merge",
+    "branch.delete",
+    "worktree.force-cleanup",
+];
+const revisionSchema = z.object({
+    commit: z
+        .string()
+        .regex(/^[0-9a-f]{7,64}$/i)
+        .transform((value) => value.toLowerCase()),
+    ref: identifier.optional(),
+});
+const dirtyStateSchema = z
+    .object({
+    status: z.enum(["clean", "dirty"]),
+    fingerprint: z
+        .string()
+        .regex(/^(?:sha256):[0-9a-f]{64}$|^(?:sha512):[0-9a-f]{128}$/i)
+        .transform((value) => value.toLowerCase()),
+    changedPaths: z.array(workspacePath).max(CAPABILITY_MAX_LIST_ITEMS),
+})
+    .superRefine((value, context) => {
+    if (value.status === "dirty" && value.changedPaths.length === 0)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["changedPaths"],
+            message: "dirty state must identify changed paths",
+        });
+    if (value.status === "clean" && value.changedPaths.length > 0)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["changedPaths"],
+            message: "clean state cannot identify changed paths",
+        });
+});
+const repositorySchema = z.object({
+    repository: z.object({ provider: identifier, id: identifier, revision: z.string().max(256).optional() }),
+    checkout: WorkspacePathRefSchema,
+    head: revisionSchema,
+    dirty: dirtyStateSchema,
+    owner: CapabilityOwnerSchema,
+});
+const worktreeSchema = z
+    .object({
+    version: z.literal(GIT_CAPABILITY_CONTRACT_VERSION),
+    id: identifier,
+    repository: repositorySchema,
+    path: WorkspacePathRefSchema,
+    branch: z
+        .string()
+        .min(1)
+        .max(GIT_MAX_BRANCH_NAME_LENGTH)
+        .regex(/^[A-Za-z0-9._/-]+$/),
+    base: revisionSchema,
+    head: revisionSchema,
+    sourceDirty: dirtyStateSchema,
+    owner: CapabilityOwnerSchema,
+    status: z.enum(["active", "cleanup-pending", "cleaned"]),
+    createdAt: timestamp,
+    cleanedAt: timestamp.optional(),
+})
+    .superRefine((value, context) => {
+    if (value.status === "cleaned" && value.cleanedAt === undefined)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["cleanedAt"],
+            message: "cleaned worktree must record cleanedAt",
+        });
+    if (value.status !== "cleaned" && value.cleanedAt !== undefined)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["cleanedAt"],
+            message: "active worktree cannot record cleanedAt",
+        });
+});
+const diffFileSchema = z.object({
+    path: workspacePath,
+    status: z.enum(["added", "copied", "deleted", "modified", "renamed", "type-changed", "untracked"]),
+    previousPath: workspacePath.optional(),
+    contentHash: z
+        .string()
+        .regex(/^(?:sha256):[0-9a-f]{64}$|^(?:sha512):[0-9a-f]{128}$/i)
+        .transform((value) => value.toLowerCase()),
+    sizeBytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+});
+const diffEvidenceSchema = z
+    .object({
+    version: z.literal(GIT_CAPABILITY_CONTRACT_VERSION),
+    repository: z.object({ provider: identifier, id: identifier, revision: z.string().max(256).optional() }),
+    worktree: worktreeSchema,
+    base: revisionSchema,
+    head: revisionSchema,
+    dirty: dirtyStateSchema,
+    files: z.array(diffFileSchema).max(GIT_MAX_CHANGED_FILES),
+    evidenceHash: z
+        .string()
+        .regex(/^(?:sha256):[0-9a-f]{64}$|^(?:sha512):[0-9a-f]{128}$/i)
+        .transform((value) => value.toLowerCase()),
+    capturedAt: timestamp,
+})
+    .superRefine((value, context) => {
+    if (value.repository.provider !== value.worktree.repository.repository.provider ||
+        value.repository.id !== value.worktree.repository.repository.id)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["repository"],
+            message: "must match worktree repository identity",
+        });
+    if (value.base.commit !== value.worktree.base.commit)
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["base"], message: "must match worktree base revision" });
+    if (value.head.commit !== value.worktree.head.commit)
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["head"], message: "must match worktree head revision" });
+    if (value.dirty.fingerprint !== value.worktree.sourceDirty.fingerprint)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["dirty"],
+            message: "must match worktree source dirty identity",
+        });
+});
+function parse(schema, value, label) {
+    const result = schema.safeParse(value);
+    if (!result.success)
+        throw new CapabilityContractError(`${label}: ${result.error.issues.map((issue) => issue.message).join("; ")}`);
+    return result.data;
+}
+function immutable(value) {
+    const snapshot = structuredClone(value);
+    const freeze = (item) => {
+        if (item === null || typeof item !== "object" || Object.isFrozen(item))
+            return;
+        for (const child of Object.values(item))
+            freeze(child);
+        Object.freeze(item);
+    };
+    freeze(snapshot);
+    return snapshot;
+}
+export function parseGitDirtyState(value) {
+    const parsed = parse(dirtyStateSchema, value, "git dirty state");
+    return immutable({ ...parsed, changedPaths: [...new Set(parsed.changedPaths)].sort() });
+}
+export function parseGitRepositoryIdentity(value) {
+    const parsed = parse(repositorySchema, value, "git repository identity");
+    return immutable({ ...parsed, dirty: parseGitDirtyState(parsed.dirty) });
+}
+export function parseGitWorktreeIdentity(value) {
+    const parsed = parse(worktreeSchema, value, "git worktree identity");
+    return immutable({
+        ...parsed,
+        repository: { ...parsed.repository, dirty: parseGitDirtyState(parsed.repository.dirty) },
+        sourceDirty: parseGitDirtyState(parsed.sourceDirty),
+    });
+}
+export function parseGitDiffEvidence(value) {
+    const parsed = parse(diffEvidenceSchema, value, "git diff evidence");
+    return immutable({
+        ...parsed,
+        dirty: parseGitDirtyState(parsed.dirty),
+        worktree: parseGitWorktreeIdentity(parsed.worktree),
+    });
+}
+export function parseGitWorktreeCreateRequest(value) {
+    const schema = z.object({
+        policy: z.custom(),
+        owner: CapabilityOwnerSchema,
+        repository: repositorySchema,
+        base: revisionSchema,
+        branch: z
+            .string()
+            .min(1)
+            .max(GIT_MAX_BRANCH_NAME_LENGTH)
+            .regex(/^[A-Za-z0-9._/-]+$/),
+        path: WorkspacePathRefSchema.optional(),
+        preserveSourceChanges: z.literal(true),
+    });
+    const parsed = parse(schema, value, "git worktree create request");
+    return immutable({ ...parsed, repository: parseGitRepositoryIdentity(parsed.repository) });
+}
+export function gitCapabilityScope(operation) {
+    if (operation === "worktree.create" || operation === "worktree.cleanup")
+        return capabilityScope(["read", "write"], [`git.${operation}`]);
+    return capabilityScope(["read"], [`git.${operation}`]);
+}
+export function assertGitOperationAllowed(operation) {
+    if (GIT_OPERATIONS.includes(operation))
+        return;
+    if (GIT_DESTRUCTIVE_OPERATIONS.includes(operation))
+        throw new CapabilityContractError(`destructive git operation is denied: ${operation}`);
+    throw new CapabilityContractError(`unsupported git operation: ${operation}`);
+}
+export function parseGitOperation(value) {
+    if (typeof value !== "string")
+        throw new CapabilityContractError("git operation must be a string");
+    assertGitOperationAllowed(value);
+    return value;
+}
+export function assertGitPolicyAllowed(result) {
+    assertAuthorized(result, { allowSandbox: true });
+}
+export function assertGitOwner(repository, owner) {
+    assertOwned(repository.owner, parseCapabilityOwner(owner));
+}
+export function workspacePathForGit(value) {
+    return parseWorkspacePathRef(value);
+}

package/dist/GlobalLogger.d.ts

@@ -5,6 +5,8 @@ export default abstract class GlobalLogger implements LoggerContext {
     abstract log(message: string): void;
     abstract logLevel(level: string, message: string): void;
     abstract error(message: string, stack: string): void;
+    /** Loggers that filter by level override this; the base emits everything. */
+    isLevelEnabled(_level?: string): boolean;
     getLogs(): string[];
     getLogsAsText(): string;
     getLogsAsBase64(): string;

package/dist/GlobalLogger.js

@@ -3,6 +3,10 @@ export default class GlobalLogger {
     constructor() {
         this.logs = [];
     }
+    /** Loggers that filter by level override this; the base emits everything. */
+    isLevelEnabled(_level = "info") {
+        return true;
+    }
     getLogs() {
         return this.logs;
     }