qlogicagent 2.13.3 → 2.13.5

package/dist/runtime/prompt/system-prompt-sections.d.ts

@@ -0,0 +1,65 @@
+/**
+ * System Prompt Sections — CC systemPromptSections.ts parity.
+ *
+ * Provides a section-based system prompt assembly mechanism:
+ *   - Memoized sections (computed once, cached until clear)
+ *   - Volatile sections (recompute every turn, cache-breaking)
+ *   - User-provided appendSystemPrompt / customSystemPrompt
+ *   - Clear on session reset / compact
+ *
+ * CC reference: src/constants/systemPromptSections.ts
+ */
+type ComputeFn = () => string | null | Promise<string | null>;
+export interface SystemPromptSection {
+    name: string;
+    compute: ComputeFn;
+    /** If true, recompute every turn (breaks prompt cache). CC: cacheBreak. */
+    cacheBreak: boolean;
+}
+/**
+ * Create a memoized system prompt section.
+ * Computed once, cached until clearSystemPromptSections() is called.
+ */
+export declare function systemPromptSection(name: string, compute: ComputeFn): SystemPromptSection;
+/**
+ * Create a volatile system prompt section that recomputes every turn.
+ * WARNING: This WILL break prompt cache when the value changes.
+ * Use sparingly — only for time-sensitive or frequently changing context.
+ *
+ * @param _reason - Why this section must be volatile (documentation only, CC parity).
+ */
+export declare function volatileSystemPromptSection(name: string, compute: ComputeFn, _reason?: string): SystemPromptSection;
+/**
+ * Resolve all system prompt sections, returning non-null prompt strings.
+ * Memoized sections are cached; volatile sections are always recomputed.
+ */
+export declare function resolveSystemPromptSections(sections: SystemPromptSection[]): Promise<string[]>;
+/**
+ * Clear all section caches. Called on session reset, /clear, or /compact.
+ */
+export declare function clearSystemPromptSections(): void;
+export interface SystemPromptAssemblyOptions {
+    /** Include the current prompt policy version header. Defaults to true. */
+    includePromptPolicy?: boolean;
+    /** Base system prompt (from Gateway config) */
+    basePrompt?: string;
+    /** Prepended instruction block (from INSTRUCTIONS.md files) */
+    instructionBlock?: string;
+    /** User-provided custom system prompt (replaces base) */
+    customSystemPrompt?: string;
+    /** User-provided append text (appended after all sections) */
+    appendSystemPrompt?: string;
+    /** Dynamic sections to resolve */
+    sections?: SystemPromptSection[];
+}
+/**
+ * Assemble the final system prompt from all sources.
+ *
+ * Order:
+ *   1. Instruction block (INSTRUCTIONS.md files)
+ *   2. Custom system prompt (replaces base) OR base prompt
+ *   3. Resolved sections
+ *   4. Append system prompt (user-provided suffix)
+ */
+export declare function assembleSystemPrompt(opts: SystemPromptAssemblyOptions): Promise<string>;
+export {};

package/dist/runtime/prompt/system-prompt-sections.js

@@ -0,0 +1,93 @@
+/**
+ * System Prompt Sections — CC systemPromptSections.ts parity.
+ *
+ * Provides a section-based system prompt assembly mechanism:
+ *   - Memoized sections (computed once, cached until clear)
+ *   - Volatile sections (recompute every turn, cache-breaking)
+ *   - User-provided appendSystemPrompt / customSystemPrompt
+ *   - Clear on session reset / compact
+ *
+ * CC reference: src/constants/systemPromptSections.ts
+ */
+// ── Types ───────────────────────────────────────────────────
+import { createPromptPolicyHeader } from "./prompt-policy.js";
+// ── Section Factories ───────────────────────────────────────
+/**
+ * Create a memoized system prompt section.
+ * Computed once, cached until clearSystemPromptSections() is called.
+ */
+export function systemPromptSection(name, compute) {
+    return { name, compute, cacheBreak: false };
+}
+/**
+ * Create a volatile system prompt section that recomputes every turn.
+ * WARNING: This WILL break prompt cache when the value changes.
+ * Use sparingly — only for time-sensitive or frequently changing context.
+ *
+ * @param _reason - Why this section must be volatile (documentation only, CC parity).
+ */
+export function volatileSystemPromptSection(name, compute, _reason) {
+    return { name, compute, cacheBreak: true };
+}
+// ── Section Registry ────────────────────────────────────────
+const sectionCache = new Map();
+/**
+ * Resolve all system prompt sections, returning non-null prompt strings.
+ * Memoized sections are cached; volatile sections are always recomputed.
+ */
+export async function resolveSystemPromptSections(sections) {
+    // CC parity: resolve all sections in parallel (Promise.all)
+    const resolved = await Promise.all(sections.map(async (section) => {
+        // Memoized: use cache if available
+        if (!section.cacheBreak && sectionCache.has(section.name)) {
+            return sectionCache.get(section.name) ?? null;
+        }
+        // Compute
+        const value = await section.compute();
+        sectionCache.set(section.name, value);
+        return value;
+    }));
+    return resolved.filter((v) => v != null);
+}
+/**
+ * Clear all section caches. Called on session reset, /clear, or /compact.
+ */
+export function clearSystemPromptSections() {
+    sectionCache.clear();
+}
+/**
+ * Assemble the final system prompt from all sources.
+ *
+ * Order:
+ *   1. Instruction block (INSTRUCTIONS.md files)
+ *   2. Custom system prompt (replaces base) OR base prompt
+ *   3. Resolved sections
+ *   4. Append system prompt (user-provided suffix)
+ */
+export async function assembleSystemPrompt(opts) {
+    const parts = [];
+    if (opts.includePromptPolicy !== false) {
+        parts.push(createPromptPolicyHeader());
+    }
+    // 1. Instructions (always first — CC parity)
+    if (opts.instructionBlock) {
+        parts.push(opts.instructionBlock);
+    }
+    // 2. Base or custom prompt
+    if (opts.customSystemPrompt) {
+        parts.push(opts.customSystemPrompt);
+    }
+    else if (opts.basePrompt) {
+        parts.push(opts.basePrompt);
+    }
+    // 3. Dynamic sections
+    if (opts.sections?.length) {
+        const sectionTexts = await resolveSystemPromptSections(opts.sections);
+        parts.push(...sectionTexts);
+    }
+    // 4. User append
+    if (opts.appendSystemPrompt) {
+        parts.push(opts.appendSystemPrompt);
+    }
+    return parts.filter(Boolean).join("\n\n");
+}

package/dist/runtime/prompt/task-domain.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Task Domain Detection — three-tier domain resolution for system prompt routing.
+ *
+ * qlogicagent handles coding, office, AND creative tasks.
+ * A coding-only system prompt hurts non-coding performance.
+ *
+ * Resolution priority (highest → lowest):
+ *   1. Project file: `.qlogicagent/settings.yaml` → `taskDomain: coding`
+ *      Persisted, user-editable, checked into repo. Strongest signal.
+ *   2. Host override: `config.taskDomain` in thread.turn params.
+ *      Set by Electron/Hub per-request.
+ *   3. Session sticky: once a domain is established in a session,
+ *      keep it unless a new turn has a STRONG signal for a different domain.
+ *   4. Auto-detect: regex keyword matching on the current user message.
+ *      Falls back to "general" if ambiguous.
+ *
+ * The `resolveTaskDomain()` function implements this full chain.
+ * The `detectTaskDomain()` function is the low-level keyword matcher (tier 4).
+ */
+/**
+ * Task domain determines which system prompt sections are injected.
+ *
+ * - "coding" — software engineering: bug fixes, refactoring, code gen, etc.
+ * - "office" — data analysis, reports, documents, spreadsheets, emails
+ * - "creative" — writing, copywriting, marketing, storytelling, brainstorming
+ * - "general" — undetectable or mixed domain, uses universal guidance
+ */
+export type TaskDomain = "coding" | "office" | "creative" | "general";
+/**
+ * Load task domain from project-level `.qlogicagent/settings.yaml`.
+ * Returns undefined if file doesn't exist or doesn't contain a valid domain.
+ *
+ * Uses sync I/O — called once per turn, file is tiny (<1KB).
+ * Simple key:value parser (no YAML dependency needed for this).
+ */
+export declare function loadProjectTaskDomain(cwd: string): TaskDomain | undefined;
+/**
+ * Detect task domain from user message text (tier 4 — lowest priority).
+ * Uses keyword matching — fast, no LLM call.
+ */
+export declare function detectTaskDomain(userText: string): TaskDomain;
+export interface DomainResolutionContext {
+    /** Current working directory (for project file lookup). */
+    cwd: string;
+    /** Host-provided override from config.taskDomain. */
+    hostOverride?: TaskDomain;
+    /** Previous session domain (for stickiness). */
+    sessionDomain?: TaskDomain;
+    /** Current turn's user message text. */
+    userText: string;
+}
+/**
+ * Full domain resolution chain — implements the four-tier priority:
+ *   1. Project file (.qlogicagent/settings.yaml or INSTRUCTIONS.md frontmatter)
+ *   2. Host override (config.taskDomain)
+ *   3. Session stickiness (keep previous domain unless strong signal)
+ *   4. Auto-detect from keywords
+ *
+ * Returns both the resolved domain and a "source" tag for debugging.
+ */
+export declare function resolveTaskDomain(ctx: DomainResolutionContext): {
+    domain: TaskDomain;
+    source: "project-file" | "host-override" | "session-sticky" | "auto-detect";
+};
+/**
+ * Persist the detected task domain to `.qlogicagent/settings.yaml`.
+ *
+ * This runs once per workspace — subsequent sessions skip auto-detect
+ * and hit Tier 1 (project file) directly.
+ *
+ * Conditions for writing:
+ *   - `domain` is NOT "general" (ambiguous → don't commit)
+ *   - No existing `settings.yaml` with a `taskDomain` line
+ *   - The auto-detect score was above the confidence threshold
+ *
+ * The written file is user-editable and meant to be checked into the repo.
+ */
+export declare function persistTaskDomain(cwd: string, domain: TaskDomain): boolean;
+/**
+ * Check if auto-detect scored high enough to justify persisting.
+ */
+export declare function shouldPersistDomain(userText: string, domain: TaskDomain): boolean;

package/dist/runtime/prompt/task-domain.js

@@ -0,0 +1,248 @@
+/**
+ * Task Domain Detection — three-tier domain resolution for system prompt routing.
+ *
+ * qlogicagent handles coding, office, AND creative tasks.
+ * A coding-only system prompt hurts non-coding performance.
+ *
+ * Resolution priority (highest → lowest):
+ *   1. Project file: `.qlogicagent/settings.yaml` → `taskDomain: coding`
+ *      Persisted, user-editable, checked into repo. Strongest signal.
+ *   2. Host override: `config.taskDomain` in thread.turn params.
+ *      Set by Electron/Hub per-request.
+ *   3. Session sticky: once a domain is established in a session,
+ *      keep it unless a new turn has a STRONG signal for a different domain.
+ *   4. Auto-detect: regex keyword matching on the current user message.
+ *      Falls back to "general" if ambiguous.
+ *
+ * The `resolveTaskDomain()` function implements this full chain.
+ * The `detectTaskDomain()` function is the low-level keyword matcher (tier 4).
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getDefaultPathService } from "../infra/default-path-service.js";
+const VALID_DOMAINS = new Set(["coding", "office", "creative", "general"]);
+// ── Tier 1: Project File ────────────────────────────────────
+/**
+ * Settings file name within `.qlogicagent/` directory.
+ * User-editable YAML (or simple key:value) file.
+ *
+ * Example `.qlogicagent/settings.yaml`:
+ * ```yaml
+ * # Task domain for this project.
+ * # Values: coding | office | creative | general
+ * taskDomain: coding
+ * ```
+ */
+const SETTINGS_FILENAME = "settings.yaml";
+/**
+ * Load task domain from project-level `.qlogicagent/settings.yaml`.
+ * Returns undefined if file doesn't exist or doesn't contain a valid domain.
+ *
+ * Uses sync I/O — called once per turn, file is tiny (<1KB).
+ * Simple key:value parser (no YAML dependency needed for this).
+ */
+export function loadProjectTaskDomain(cwd) {
+    try {
+        const settingsPath = getDefaultPathService().getProjectSettingsPath(cwd);
+        const content = readFileSync(settingsPath, "utf-8");
+        // Simple regex extraction — supports `taskDomain: coding` in YAML or plain text
+        const match = content.match(/^taskDomain\s*:\s*(\w+)/m);
+        if (match) {
+            const value = match[1].toLowerCase();
+            if (VALID_DOMAINS.has(value))
+                return value;
+        }
+    }
+    catch {
+        // File doesn't exist or unreadable — silent fallthrough
+    }
+    // Also check INSTRUCTIONS.md frontmatter for `domain:` field
+    try {
+        const instructionsPath = getDefaultPathService().getProjectInstructionsPath(cwd);
+        const content = readFileSync(instructionsPath, "utf-8");
+        const fmMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+        if (fmMatch) {
+            const domainMatch = fmMatch[0].match(/^domain\s*:\s*(\w+)/m);
+            if (domainMatch) {
+                const value = domainMatch[1].toLowerCase();
+                if (VALID_DOMAINS.has(value))
+                    return value;
+            }
+        }
+    }
+    catch {
+        // Silent fallthrough
+    }
+    // Also check root-level INSTRUCTIONS.md
+    try {
+        const rootInstructions = join(cwd, "INSTRUCTIONS.md");
+        const content = readFileSync(rootInstructions, "utf-8");
+        const fmMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+        if (fmMatch) {
+            const domainMatch = fmMatch[0].match(/^domain\s*:\s*(\w+)/m);
+            if (domainMatch) {
+                const value = domainMatch[1].toLowerCase();
+                if (VALID_DOMAINS.has(value))
+                    return value;
+            }
+        }
+    }
+    catch {
+        // Silent fallthrough
+    }
+    return undefined;
+}
+// ── Tier 3: Session Stickiness ──────────────────────────────
+/**
+ * Minimum keyword score required to OVERRIDE an existing session domain.
+ * Higher than the initial detection threshold — requires a clear signal shift.
+ */
+const DOMAIN_SWITCH_THRESHOLD = 3;
+/**
+ * Resolve task domain with session stickiness.
+ * If a previous domain is established, require a stronger signal to switch.
+ */
+function resolveWithStickiness(userText, previousDomain) {
+    const detected = detectTaskDomain(userText);
+    // No previous domain → use whatever we detected
+    if (!previousDomain)
+        return detected;
+    // Detected same as previous → keep it
+    if (detected === previousDomain)
+        return previousDomain;
+    // Detected "general" → keep previous (generic messages shouldn't break stickiness)
+    if (detected === "general")
+        return previousDomain;
+    // Detected a DIFFERENT specific domain → require strong signal
+    const scores = scoreAllDomains(userText);
+    const newDomainScore = scores[detected] ?? 0;
+    if (newDomainScore >= DOMAIN_SWITCH_THRESHOLD)
+        return detected;
+    // Not strong enough → keep previous
+    return previousDomain;
+}
+// ── Tier 4: Keyword Auto-Detect ─────────────────────────────
+const CODING_PATTERN = /\b(?:code|coding|bug|debug|fix|refactor|function|class|method|api|compile|build|deploy|test|unittest|lint|git|commit|merge|branch|pull\s*request|PR|npm|pnpm|yarn|pip|docker|k8s|kubernetes|sql|database|migration|endpoint|route|middleware|typescript|javascript|python|java|rust|go(?:lang)?|css|html|react|vue|angular|nextjs|express|fastapi|flask|django|springboot|webpack|vite|rollup|esbuild|CI\/?CD|GitHub\s*Actions|workflow|pipeline|variable|const|let|var|import|export|module|package|dependency|dependencies|node_modules|tsconfig|eslint|prettier|interface|type\b|enum|struct|async|await|promise|callback|exception|error\s*handling|stack\s*trace|breakpoint|源码|代码|编程|编码|调试|重构|修复|Bug|函数|类|方法|接口|模块|依赖|组件|编译|构建|部署|测试|单元测试|提交|合并|分支|数据库|迁移|路由|中间件)\b/i;
+const OFFICE_PATTERN = /\b(?:report|document|spreadsheet|excel|csv|table|chart|graph|data\s*analysis|statistics|slides?|presentation|ppt|powerpoint|email|mail|memo|minutes|meeting|schedule|calendar|summary|summarize|brief|overview|outline|template|format|agenda|invoice|budget|forecast|dashboard|KPI|OKR|metric|analytics|insight|文档|报告|报表|表格|数据分析|统计|幻灯片|PPT|演示|邮件|信件|备忘录|会议纪要|日程|摘要|总结|概要|简报|模板|格式|议程|发票|预算|预测|看板|报表|分析)\b/i;
+const CREATIVE_PATTERN = /\b(?:write|writing|essay|article|blog|story|novel|poem|poetry|lyrics|copywriting|copy|slogan|tagline|headline|marketing|campaign|branding|creative|brainstorm|idea|concept|draft|narrative|character|dialogue|script|screenplay|pitch|proposal|content\s*strategy|social\s*media|SEO|newsletter|press\s*release|写作|文章|博客|故事|小说|诗|歌词|文案|标语|营销|策划|品牌|创意|头脑风暴|灵感|构思|草稿|叙事|角色|对话|剧本|策划案|提案|内容策略|自媒体|公众号|推文|软文|种草)\b/i;
+/**
+ * Detect task domain from user message text (tier 4 — lowest priority).
+ * Uses keyword matching — fast, no LLM call.
+ */
+export function detectTaskDomain(userText) {
+    if (!userText || userText.trim().length === 0)
+        return "general";
+    const scores = scoreAllDomains(userText);
+    const maxScore = Math.max(scores.coding, scores.office, scores.creative);
+    if (maxScore === 0)
+        return "general";
+    // If scores are close (within 1), treat as mixed → general
+    const topCount = [scores.coding, scores.office, scores.creative]
+        .filter(s => s >= maxScore - 1 && s > 0).length;
+    if (topCount >= 2 && maxScore <= 2)
+        return "general";
+    if (scores.coding === maxScore)
+        return "coding";
+    if (scores.office === maxScore)
+        return "office";
+    if (scores.creative === maxScore)
+        return "creative";
+    return "general";
+}
+function scoreAllDomains(text) {
+    return {
+        coding: countMatches(text, CODING_PATTERN),
+        office: countMatches(text, OFFICE_PATTERN),
+        creative: countMatches(text, CREATIVE_PATTERN),
+        general: 0,
+    };
+}
+function countMatches(text, pattern) {
+    const globalPattern = new RegExp(pattern.source, "gi");
+    const matches = text.match(globalPattern);
+    return matches ? matches.length : 0;
+}
+/**
+ * Full domain resolution chain — implements the four-tier priority:
+ *   1. Project file (.qlogicagent/settings.yaml or INSTRUCTIONS.md frontmatter)
+ *   2. Host override (config.taskDomain)
+ *   3. Session stickiness (keep previous domain unless strong signal)
+ *   4. Auto-detect from keywords
+ *
+ * Returns both the resolved domain and a "source" tag for debugging.
+ */
+export function resolveTaskDomain(ctx) {
+    // Tier 1: Project file
+    const projectDomain = loadProjectTaskDomain(ctx.cwd);
+    if (projectDomain) {
+        return { domain: projectDomain, source: "project-file" };
+    }
+    // Tier 2: Host override
+    if (ctx.hostOverride && VALID_DOMAINS.has(ctx.hostOverride)) {
+        return { domain: ctx.hostOverride, source: "host-override" };
+    }
+    // Tier 3+4: Session stickiness wrapping auto-detect
+    const resolved = resolveWithStickiness(ctx.userText, ctx.sessionDomain);
+    if (ctx.sessionDomain && resolved === ctx.sessionDomain) {
+        return { domain: resolved, source: "session-sticky" };
+    }
+    return { domain: resolved, source: "auto-detect" };
+}
+// ── Persistence: auto-write project settings ────────────────
+/**
+ * Minimum keyword score required before we auto-persist a domain.
+ * Must be a strong, unambiguous signal — we're writing a file to disk.
+ */
+const AUTO_PERSIST_MIN_SCORE = 3;
+/**
+ * Persist the detected task domain to `.qlogicagent/settings.yaml`.
+ *
+ * This runs once per workspace — subsequent sessions skip auto-detect
+ * and hit Tier 1 (project file) directly.
+ *
+ * Conditions for writing:
+ *   - `domain` is NOT "general" (ambiguous → don't commit)
+ *   - No existing `settings.yaml` with a `taskDomain` line
+ *   - The auto-detect score was above the confidence threshold
+ *
+ * The written file is user-editable and meant to be checked into the repo.
+ */
+export function persistTaskDomain(cwd, domain) {
+    if (domain === "general")
+        return false;
+    try {
+        const dotDir = getDefaultPathService().getProjectAgentDir(cwd);
+        const settingsPath = join(dotDir, SETTINGS_FILENAME);
+        // Don't overwrite if a settings file already declares taskDomain
+        if (existsSync(settingsPath)) {
+            const existing = readFileSync(settingsPath, "utf-8");
+            if (/^taskDomain\s*:/m.test(existing))
+                return false;
+        }
+        // Ensure .qlogicagent/ directory exists
+        mkdirSync(dotDir, { recursive: true });
+        // Append or create — preserve existing content if any
+        const header = "# Auto-detected task domain for this workspace.\n# Values: coding | office | creative | general\n";
+        if (existsSync(settingsPath)) {
+            const existing = readFileSync(settingsPath, "utf-8");
+            writeFileSync(settingsPath, existing.trimEnd() + "\n\n" + header + `taskDomain: ${domain}\n`, "utf-8");
+        }
+        else {
+            writeFileSync(settingsPath, header + `taskDomain: ${domain}\n`, "utf-8");
+        }
+        return true;
+    }
+    catch {
+        // Non-fatal — read-only filesystem, permission issues, etc.
+        return false;
+    }
+}
+/**
+ * Check if auto-detect scored high enough to justify persisting.
+ */
+export function shouldPersistDomain(userText, domain) {
+    if (domain === "general")
+        return false;
+    const scores = scoreAllDomains(userText);
+    return (scores[domain] ?? 0) >= AUTO_PERSIST_MIN_SCORE;
+}

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

@@ -0,0 +1,2 @@
+export * from "./skill-sandbox.js";
+export * from "./windows-skill-sandbox.js";

package/dist/runtime/sandbox/index.js

@@ -0,0 +1,2 @@
+export * from "./skill-sandbox.js";
+export * from "./windows-skill-sandbox.js";

package/dist/runtime/sandbox/skill-sandbox.d.ts

@@ -0,0 +1,53 @@
+import { buildWindowsProcessTreeLauncherAuditEnvelope, type WindowsSkillSandboxAvailability } from "./windows-skill-sandbox.js";
+export type SkillSandboxOrigin = "community" | "first-party" | "official";
+export type SkillSandboxRiskTier = "R0" | "R1" | "R2" | "R3" | "unknown";
+export type SkillSandboxDecisionReason = "first-party-action" | "community-low-risk" | "manual-run" | "l0-available" | "l0-unavailable" | "launcher-required" | "launcher-unavailable";
+export interface SkillSandboxAvailability extends WindowsSkillSandboxAvailability {
+}
+export interface SkillSandboxRunRequest {
+    origin: SkillSandboxOrigin;
+    official?: boolean;
+    riskTier?: SkillSandboxRiskTier;
+    autoRun?: boolean;
+    executable?: boolean;
+}
+export interface SkillSandboxLauncherDecisionMetadata {
+    level: "L0";
+    mode: "os-native-launcher";
+    defaultHostAccess: true;
+    noFsNetworkRestriction: true;
+    audit: {
+        envelope: "l0-launcher-audit-v1";
+        subject: {
+            origin: SkillSandboxOrigin;
+            official: boolean;
+            executable: boolean;
+            autoRun: boolean;
+        };
+        decision: "allowed" | "blocked";
+        reason: "launcher-required" | "launcher-unavailable";
+    };
+    windows?: ReturnType<typeof buildWindowsProcessTreeLauncherAuditEnvelope>;
+}
+export interface SkillSandboxDecision {
+    allowed: boolean;
+    spawnAllowed: boolean;
+    launcherRequired: boolean;
+    reason: SkillSandboxDecisionReason;
+    backend: "first-party" | "community-l1-l2" | "community-l0" | "community-l0-launcher";
+    l0: SkillSandboxAvailability;
+    launcher?: SkillSandboxLauncherDecisionMetadata;
+}
+export interface SkillSandbox {
+    getAvailability(): SkillSandboxAvailability;
+    decide(request: SkillSandboxRunRequest): SkillSandboxDecision;
+}
+export interface SkillSandboxOptions {
+    availability?: SkillSandboxAvailability;
+    platform?: string;
+    appContainerAvailable?: boolean;
+    jobObjectAvailable?: boolean;
+    processTreeLauncherAvailable?: boolean;
+}
+export declare function createSkillSandbox(options?: SkillSandboxOptions): SkillSandbox;
+export declare function createDefaultSkillSandbox(): SkillSandbox;

package/dist/runtime/sandbox/skill-sandbox.js

@@ -0,0 +1,93 @@
+import { buildWindowsProcessTreeLauncherAuditEnvelope, getWindowsSkillSandboxAvailability, } from "./windows-skill-sandbox.js";
+export function createSkillSandbox(options = {}) {
+    const l0 = options.availability ?? getWindowsSkillSandboxAvailability({
+        platform: options.platform,
+        appContainerAvailable: options.appContainerAvailable,
+        jobObjectAvailable: options.jobObjectAvailable,
+        processTreeLauncherAvailable: options.processTreeLauncherAvailable,
+    });
+    return {
+        getAvailability() {
+            return l0;
+        },
+        decide(request) {
+            if (request.origin === "first-party" || request.origin === "official" || request.official === true) {
+                return {
+                    allowed: true,
+                    spawnAllowed: true,
+                    launcherRequired: false,
+                    reason: "first-party-action",
+                    backend: "first-party",
+                    l0,
+                };
+            }
+            if (request.origin === "community" && request.executable === true) {
+                const reason = l0.available ? "launcher-required" : "launcher-unavailable";
+                return {
+                    allowed: l0.available,
+                    spawnAllowed: l0.available,
+                    launcherRequired: true,
+                    reason,
+                    backend: "community-l0-launcher",
+                    l0,
+                    launcher: buildLauncherDecisionMetadata(request, l0.available ? "allowed" : "blocked", reason),
+                };
+            }
+            const riskTier = request.riskTier ?? "unknown";
+            if (!isHighRisk(riskTier) || !request.executable) {
+                return {
+                    allowed: true,
+                    spawnAllowed: true,
+                    launcherRequired: false,
+                    reason: "community-low-risk",
+                    backend: "community-l1-l2",
+                    l0,
+                };
+            }
+            if (request.autoRun === false) {
+                return {
+                    allowed: true,
+                    spawnAllowed: true,
+                    launcherRequired: false,
+                    reason: "manual-run",
+                    backend: "community-l1-l2",
+                    l0,
+                };
+            }
+            return {
+                allowed: l0.available,
+                spawnAllowed: l0.available,
+                launcherRequired: true,
+                reason: l0.available ? "l0-available" : "l0-unavailable",
+                backend: "community-l0",
+                l0,
+            };
+        },
+    };
+}
+export function createDefaultSkillSandbox() {
+    return createSkillSandbox();
+}
+function isHighRisk(riskTier) {
+    return riskTier === "R2" || riskTier === "R3";
+}
+function buildLauncherDecisionMetadata(request, decision, reason) {
+    return {
+        level: "L0",
+        mode: "os-native-launcher",
+        defaultHostAccess: true,
+        noFsNetworkRestriction: true,
+        audit: {
+            envelope: "l0-launcher-audit-v1",
+            subject: {
+                origin: request.origin,
+                official: request.official === true,
+                executable: request.executable === true,
+                autoRun: request.autoRun === true,
+            },
+            decision,
+            reason,
+        },
+        windows: buildWindowsProcessTreeLauncherAuditEnvelope(),
+    };
+}

package/dist/runtime/sandbox/skill-sandbox.test.d.ts

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