sneakoscope 6.0.3 → 6.1.2

package/dist/core/managed-assets/managed-assets-manifest.js

@@ -1,6 +1,8 @@
+import { sha256 } from '../fsx.js';
 export const MANAGED_ASSET_SCHEMA_VERSION = 1;
-export const MANAGED_ASSET_VERSION = '4.8.1';
+export const MANAGED_ASSET_VERSION = '6.1.2';
 export const MANAGED_ASSET_MARKER = 'SKS-MANAGED-ASSET';
+export const MANAGED_OFFICIAL_SUBAGENT_MARKER = 'SKS-MANAGED-OFFICIAL-SUBAGENT';
 export const MANAGED_AGENT_ROLES = Object.freeze([
     role('sks-explorer', 'analysis-scout.toml', 'analysis_scout', 'SKS analysis scout for bounded read/write slices retained for stale Codex agent-role config repair.', 'workspace-write', ['analysis-scout', 'analysis_scout']),
     role('sks-native-agent', 'native-agent-intake.toml', 'native_agent', 'SKS native agent for bounded read/write intake slices.', 'workspace-write', ['native-agent-intake', 'native_agent']),
@@ -12,6 +14,295 @@ export const MANAGED_AGENT_ROLES = Object.freeze([
     role('sks-codex-probe-verifier', 'sks-codex-probe-verifier.toml', 'sks_codex_probe_verifier', 'Codex probe verifier for CLI, App, SDK, MCP, and native capability evidence with bounded write capability.', 'workspace-write', ['codex-probe-verifier']),
     role('db-safety-reviewer', 'db-safety-reviewer.toml', 'db_safety_reviewer', 'Database safety reviewer for SQL, migrations, Supabase, and rollback safety with bounded write capability.', 'workspace-write', ['db-safety-reviewer', 'db_safety_reviewer'])
 ]);
+/**
+ * Canonical project-scoped Codex custom agents for the official subagent workflow.
+ * Each role is intentionally narrow so Codex can select it from its description
+ * instead of forcing every slice through a generic worker/reviewer pair.
+ */
+export const MANAGED_OFFICIAL_SUBAGENT_ROLES = Object.freeze([
+    officialSubagentRole({
+        id: 'sks-official-worker',
+        filename: 'worker.toml',
+        aliases: ['worker'],
+        codexName: 'worker',
+        description: 'Execution-focused subagent for clear, bounded, repeatable work with an explicit done condition.',
+        model: 'gpt-5.6-luna',
+        keywords: ['bounded', 'mechanical', 'repeatable', 'rename', 'format', 'copy', 'fixture'],
+        nicknames: ['Kite', 'Moss', 'Pico', 'Reed', 'Vale', 'Wren'],
+        instructions: `You are a bounded execution subagent.
+
+Work only on the exact slice assigned by the parent agent.
+Do not redesign the task, expand scope, or spawn another subagent.
+Prefer clear, mechanical, repeatable execution.
+Respect the parent session's sandbox and approval mode.
+When writing, touch only the assigned files or paths.
+Run only the verification directly relevant to your slice.
+Return:
+1. concise result,
+2. files inspected or changed,
+3. verification performed,
+4. blockers or uncertainty.
+Do not claim success without direct evidence.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-implementation-specialist',
+        filename: 'implementation-specialist.toml',
+        aliases: ['implementation-specialist', 'core-implementer'],
+        codexName: 'implementation_specialist',
+        description: 'Sol implementation specialist for bounded backend, core, API, lifecycle, and cross-file refactors with disjoint ownership.',
+        model: 'gpt-5.6-sol',
+        keywords: ['implementation', 'backend', 'core', 'api', 'lifecycle fix', 'cross-file refactor', 'complex change', '구현', '백엔드', '핵심 로직'],
+        nicknames: ['Builder', 'Forge', 'Mason', 'Rivet'],
+        instructions: `You are the bounded complex implementation specialist.
+
+Own only the disjoint files and acceptance criteria assigned by the parent.
+Use this role for non-mechanical backend, core, API, lifecycle, and cross-file implementation.
+Do not redesign unrelated architecture or integrate sibling work.
+Make the smallest defensible change, run focused verification, and return files, evidence, and residual risks.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-expert',
+        filename: 'expert.toml',
+        aliases: ['expert'],
+        codexName: 'expert',
+        description: 'Read-only reasoning fallback for ambiguous analysis when no narrower specialist matches.',
+        model: 'gpt-5.6-sol',
+        sandbox: 'read-only',
+        keywords: ['ambiguous', 'strategy', 'planning', 'trade-off', 'risk', 'judgment'],
+        nicknames: ['Atlas', 'Delta', 'Helix', 'Orion', 'Sage', 'Vector'],
+        instructions: `You are the reasoning and judgment fallback subagent.
+
+Use this role only when no narrower SKS custom agent matches the slice.
+Stay read-only and return a decision-ready analysis to the parent.
+
+Do not spawn another subagent.
+Separate evidence from inference.
+For reviews, lead with concrete findings and file references.
+For debugging, reproduce or trace the failure before proposing a fix.
+For planning, produce a bounded plan with clear ownership and stop conditions.
+Run only verification that can change the decision.
+Return a concise result, evidence, risks, and next action.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-explorer',
+        filename: 'explorer.toml',
+        aliases: ['explorer', 'code-explorer'],
+        codexName: 'explorer',
+        description: 'Read-only codebase explorer for locating entry points, ownership, dependencies, and bounded evidence before changes.',
+        model: 'gpt-5.6-luna',
+        sandbox: 'read-only',
+        keywords: ['explore', 'map', 'trace', 'inventory', 'locate', 'search', 'read-only'],
+        nicknames: ['Beacon', 'Compass', 'Maple', 'Scout'],
+        instructions: `You are the read-only code explorer.
+
+Map only the code paths relevant to the assigned question.
+Prefer targeted search and exact symbol references over broad repository scans.
+Identify entry points, state transitions, owners, and evidence gaps.
+Do not propose a broad redesign and do not edit files.
+Return concise findings with exact paths and symbols.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-debugger',
+        filename: 'debugger.toml',
+        aliases: ['debugger', 'root-cause'],
+        codexName: 'debugger',
+        description: 'Read-only root-cause specialist for failures, flaky behavior, regressions, and cross-layer diagnostics.',
+        model: 'gpt-5.6-sol',
+        sandbox: 'read-only',
+        keywords: ['debug', 'diagnose', 'root cause', 'failure', 'flaky', 'regression', 'why'],
+        nicknames: ['Ada', 'Kepler', 'Trace', 'Vega'],
+        instructions: `You are the root-cause debugger.
+
+Reproduce or trace the failure before suggesting a fix.
+Separate observations, hypotheses, and confirmed causes.
+Inspect logs and tests narrowly; do not edit application code.
+Return the minimal causal chain, exact evidence, and the smallest defensible fix surface.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-test-engineer',
+        filename: 'test-engineer.toml',
+        aliases: ['test-engineer', 'qa-engineer'],
+        codexName: 'test_engineer',
+        description: 'Test engineer for focused regression coverage, deterministic fixtures, and failure-oriented verification.',
+        model: 'gpt-5.6-sol',
+        keywords: ['test', 'qa', 'fixture', 'regression', 'coverage', 'verification'],
+        nicknames: ['Check', 'Proof', 'Quill', 'Tess'],
+        instructions: `You are the focused test engineer.
+
+Own only the assigned test files and fixtures.
+Add the smallest regression coverage that would have caught the issue.
+Avoid duplicating production logic in assertions.
+Run only the focused checks needed for the slice and report exact commands and outcomes.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-ui-implementer',
+        filename: 'ui-implementer.toml',
+        aliases: ['ui-implementer', 'frontend-specialist'],
+        codexName: 'ui_implementer',
+        description: 'UI and terminal-interface implementation specialist for visual behavior, interaction, accessibility, and rendered state.',
+        model: 'gpt-5.6-sol',
+        keywords: ['ui', 'ux', 'frontend', 'visual', 'terminal', 'zellij', 'pane', 'accessibility'],
+        nicknames: ['Canvas', 'Iris', 'Pixel', 'Turing'],
+        instructions: `You are the UI implementation specialist.
+
+Trace the rendered user-visible behavior before editing.
+Make the smallest change that fixes interaction, layout, accessibility, or terminal presentation.
+Preserve the existing design system and unrelated behavior.
+Verify the rendered result with the appropriate live or deterministic surface and report evidence.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-architecture-reviewer',
+        filename: 'architecture-reviewer.toml',
+        aliases: ['architecture-reviewer', 'architect'],
+        codexName: 'architecture_reviewer',
+        description: 'Read-only architecture reviewer for boundaries, lifecycle, state ownership, coupling, and refactor risk.',
+        model: 'gpt-5.6-sol',
+        sandbox: 'read-only',
+        keywords: ['architecture', 'design', 'lifecycle', 'state ownership', 'refactor', 'coupling'],
+        nicknames: ['Archimedes', 'Euler', 'Frame', 'Mencius'],
+        instructions: `You are the architecture reviewer.
+
+Review boundaries, ownership, lifecycle, and failure recovery like a maintainer.
+Prefer concrete execution paths over abstract style commentary.
+Identify duplication, hidden coupling, and unsafe state transitions.
+Do not edit files; return prioritized findings and a bounded recommendation.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-security-reviewer',
+        filename: 'security-reviewer.toml',
+        aliases: ['security-reviewer', 'security'],
+        codexName: 'security_reviewer',
+        description: 'Read-only security reviewer for trust boundaries, permissions, secrets, authentication, and abuse cases.',
+        model: 'gpt-5.6-sol',
+        sandbox: 'read-only',
+        keywords: ['security', 'permission', 'secret', 'auth', 'trust boundary', 'abuse'],
+        nicknames: ['Aegis', 'Cipher', 'Sentinel', 'Shield'],
+        instructions: `You are the security reviewer.
+
+Inspect only the assigned threat surface.
+Prioritize exploitable trust-boundary failures, permission escalation, secret exposure, and unsafe defaults.
+Do not perform destructive probes or edit files.
+Return findings with severity, evidence, exploit preconditions, and the smallest mitigation.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-database-reviewer',
+        filename: 'database-reviewer.toml',
+        aliases: ['database-reviewer', 'db-reviewer'],
+        codexName: 'database_reviewer',
+        description: 'Read-only database reviewer for SQL, migrations, schemas, RLS, rollback safety, and data integrity.',
+        model: 'gpt-5.6-sol',
+        sandbox: 'read-only',
+        keywords: ['database', 'db', 'sql', 'migration', 'schema', 'rls', 'rollback'],
+        nicknames: ['Ledger', 'Oracle', 'Rowan', 'Schema'],
+        instructions: `You are the database safety reviewer.
+
+Keep all inspection read-only unless the parent supplied a separately sealed mutation contract.
+Check migration ordering, rollback, locks, RLS, data loss, and integrity assumptions.
+Never execute live mutations.
+Return exact risks, evidence, and safe verification or migration recommendations.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-research-synthesizer',
+        filename: 'research-synthesizer.toml',
+        aliases: ['research-synthesizer', 'researcher'],
+        codexName: 'research_synthesizer',
+        description: 'Evidence-bound research specialist for source synthesis, falsification, novelty, and adversarial manuscript improvement.',
+        model: 'gpt-5.6-sol',
+        keywords: ['research', 'paper', 'hypothesis', 'synthesis', 'falsification', 'novelty', 'super search'],
+        nicknames: ['Curie', 'Einstein', 'Feynman', 'Noether'],
+        instructions: `You are the evidence-bound research synthesizer.
+
+Use only cited sources and explicit experiments.
+Separate facts, inference, hypotheses, novelty claims, and unknowns.
+Actively falsify the strongest claim and revise only mission-local research artifacts.
+Do not invent evidence or promise publication acceptance.
+Return a structured synthesis, strongest challenge, required revisions, and residual uncertainty.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-research-reviewer',
+        filename: 'research-reviewer.toml',
+        aliases: ['research-reviewer', 'paper-reviewer'],
+        codexName: 'research_reviewer',
+        description: 'Read-only adversarial research reviewer for evidence quality, falsification, methodology, novelty, and reproducibility.',
+        model: 'gpt-5.6-sol',
+        sandbox: 'read-only',
+        keywords: ['research review', 'paper review', 'adversarial review', 'methodology', 'reproducibility', 'falsification'],
+        nicknames: ['Gauss', 'Skeptic', 'Turing', 'von Neumann'],
+        instructions: `You are the adversarial research reviewer.
+
+Attack the strongest claim with source-bound counterevidence, base rates, and reproducibility checks.
+Do not edit files or reward impressive language without evidence.
+Return the strongest falsification attempt, objections with required revisions, evidence source IDs, and an approve/revise/reject verdict.
+Approve only when no critical, major, minor, or required revision remains.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-release-reviewer',
+        filename: 'release-reviewer.toml',
+        aliases: ['release-reviewer', 'release'],
+        codexName: 'release_reviewer',
+        description: 'Read-only release reviewer for versioning, package contents, CI, migration safety, and publish authorization.',
+        model: 'gpt-5.6-sol',
+        sandbox: 'read-only',
+        keywords: ['release', 'publish', 'package', 'version', 'changelog', 'ci', 'distribution'],
+        nicknames: ['Galileo', 'Harbor', 'Launch', 'Mercury'],
+        instructions: `You are the release reviewer.
+
+Audit version metadata, package contents, CI workflow, migration notes, and release evidence.
+Do not publish, tag, push, or mutate package registries.
+Fail closed on stale or simulated proof.
+Return release blockers, exact evidence, and the minimal verification still required.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-docs-maintainer',
+        filename: 'docs-maintainer.toml',
+        aliases: ['docs-maintainer', 'documentation'],
+        codexName: 'docs_maintainer',
+        description: 'Documentation maintainer for bounded README, changelog, migration, and reference updates after behavior is known.',
+        model: 'gpt-5.6-luna',
+        keywords: ['docs', 'documentation', 'readme', 'changelog', 'migration guide', 'reference'],
+        nicknames: ['Ink', 'Page', 'Scribe', 'Slate'],
+        instructions: `You are the bounded documentation maintainer.
+
+Update only the assigned documentation files after behavior is established by code or official sources.
+Keep examples executable and avoid unsupported claims.
+Preserve historical notes unless the parent explicitly scopes a cleanup.
+Return changed files and the source of truth used for each behavioral statement.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-integration-reviewer',
+        filename: 'integration-reviewer.toml',
+        aliases: ['integration-reviewer', 'integration'],
+        codexName: 'integration_reviewer',
+        description: 'Read-only cross-module integration reviewer for merge risk, contracts, compatibility, and end-to-end state flow.',
+        model: 'gpt-5.6-sol',
+        sandbox: 'read-only',
+        keywords: ['integration', 'merge', 'rebase', 'compatibility', 'cross-module', 'end-to-end'],
+        nicknames: ['Bridge', 'Concord', 'Link', 'Weave'],
+        instructions: `You are the integration reviewer.
+
+Trace contracts across the assigned modules and identify incompatible assumptions or merge hazards.
+The parent owns final integration; do not edit files or combine sibling work.
+Prioritize end-to-end state flow, compatibility, and recovery behavior.
+Return concrete integration risks and focused checks.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-performance-analyst',
+        filename: 'performance-analyst.toml',
+        aliases: ['performance-analyst', 'performance'],
+        codexName: 'performance_analyst',
+        description: 'Read-only performance analyst for latency, concurrency, token cost, resource usage, and benchmark validity.',
+        model: 'gpt-5.6-sol',
+        sandbox: 'read-only',
+        keywords: ['performance', 'latency', 'benchmark', 'concurrency', 'token', 'memory', 'throughput'],
+        nicknames: ['Ampere', 'Hopper', 'Pulse', 'Watt'],
+        instructions: `You are the performance analyst.
+
+Require measured evidence before claiming improvement.
+Inspect latency, concurrency, token, memory, and resource trade-offs within the assigned scope.
+Do not edit files or extrapolate from unscored anecdotes.
+Return the measurement method, observed result, uncertainty, and next cheapest experiment.`
+    })
+]);
 export const MANAGED_SKILLS = Object.freeze([
     'loop',
     'naruto',
@@ -54,6 +345,20 @@ export function managedAgentRoleByName(name) {
         ...role.legacy_ids
     ].map(normalizeRoleName).includes(normalized)) || null;
 }
+export function managedOfficialSubagentRoleByFile(filename) {
+    const base = filename.split(/[\\/]/).pop() || filename;
+    assertUniqueManagedAgentRoleFilenames();
+    return MANAGED_OFFICIAL_SUBAGENT_ROLES.find((role) => role.filename === base) || null;
+}
+export function managedOfficialSubagentRoleByName(name) {
+    const normalized = normalizeRoleName(name);
+    return MANAGED_OFFICIAL_SUBAGENT_ROLES.find((role) => [
+        role.id,
+        role.codex_name,
+        role.filename.replace(/\.toml$/i, ''),
+        ...role.aliases
+    ].map(normalizeRoleName).includes(normalized)) || null;
+}
 export function managedAgentRoleContent(role) {
     return [
         `# ${MANAGED_ASSET_MARKER}`,
@@ -63,8 +368,6 @@ export function managedAgentRoleContent(role) {
         `name = "${role.codex_name}"`,
         `description = "${role.description}"`,
         `sandbox_mode = "${role.sandbox}"`,
-        `permission_profile = "${role.permission_profile}"`,
-        `legacy_sandbox_projection = "${role.legacy_sandbox_projection}"`,
         'developer_instructions = """',
         `You are the SKS ${role.id} role.`,
         role.sandbox === 'read-only' ? 'Do not edit files.' : 'Only edit the bounded files assigned by the parent orchestrator.',
@@ -74,21 +377,69 @@ export function managedAgentRoleContent(role) {
     ].join('\n');
 }
 export function managedAgentRoleOwnsText(text, role) {
-    const hasManagedMarker = text.includes(MANAGED_ASSET_MARKER)
-        && text.includes(`sks_managed_id = "${role.id}"`)
-        && text.includes(`name = "${role.codex_name}"`)
-        && text.includes(`sandbox_mode = "${role.sandbox}"`);
-    const legacyCompatible = text.includes(`name = "${role.codex_name}"`)
-        && text.includes(`sandbox_mode = "${role.sandbox}"`)
-        && text.includes('developer_instructions = """');
-    return hasManagedMarker || legacyCompatible;
+    const source = normalizeManagedLegacyAgentText(text);
+    if (!source.startsWith(`# ${MANAGED_ASSET_MARKER}\n`))
+        return false;
+    if (!source.includes(`# sks_managed_id = "${role.id}"\n`))
+        return false;
+    return managedLegacyAgentRoleVariants(role)
+        .map(normalizeManagedLegacyAgentText)
+        .some((candidate) => source === candidate);
+}
+export function managedOfficialSubagentRoleBody(role) {
+    return [
+        `name = "${role.codex_name}"`,
+        `description = "${role.description}"`,
+        `model = "${role.model}"`,
+        `model_reasoning_effort = "${role.model_reasoning_effort}"`,
+        ...(role.sandbox ? [`sandbox_mode = "${role.sandbox}"`] : []),
+        '',
+        'nickname_candidates = [',
+        ...role.nickname_candidates.map((nickname) => `  "${nickname}",`),
+        ']',
+        '',
+        'developer_instructions = """',
+        role.developer_instructions,
+        '"""',
+        ''
+    ].join('\n');
+}
+export function managedOfficialSubagentRoleContent(role) {
+    const body = managedOfficialSubagentRoleBody(role);
+    return [
+        `# ${MANAGED_OFFICIAL_SUBAGENT_MARKER}`,
+        `# sks_managed_schema = ${role.schema_version}`,
+        `# sks_managed_id = "${role.id}"`,
+        `# sks_managed_body_sha256 = "${sha256(body)}"`,
+        '',
+        body
+    ].join('\n');
+}
+export function managedOfficialSubagentRoleOwnsText(text, role) {
+    const source = String(text || '');
+    if (!source.includes(`# ${MANAGED_OFFICIAL_SUBAGENT_MARKER}`))
+        return false;
+    if (!source.includes(`sks_managed_id = "${role.id}"`))
+        return false;
+    const lines = source.split('\n');
+    const hashIndex = lines.findIndex((line) => /^#\s*sks_managed_body_sha256\s*=/.test(line.trim()));
+    if (hashIndex === -1)
+        return false;
+    const expectedHash = lines[hashIndex]?.match(/^#\s*sks_managed_body_sha256\s*=\s*"([a-f0-9]{64})"\s*$/i)?.[1];
+    if (!expectedHash)
+        return false;
+    const separatorIndex = lines.findIndex((line, index) => index > hashIndex && line.trim() === '');
+    if (separatorIndex === -1)
+        return false;
+    const body = lines.slice(separatorIndex + 1).join('\n');
+    return sha256(body) === expectedHash;
 }
 export function normalizeRoleName(name) {
     return String(name || '').trim().replace(/\.toml$/i, '').replace(/_/g, '-').toLowerCase();
 }
 export function assertUniqueManagedAgentRoleFilenames() {
     const seen = new Map();
-    for (const role of MANAGED_AGENT_ROLES) {
+    for (const role of [...MANAGED_AGENT_ROLES, ...MANAGED_OFFICIAL_SUBAGENT_ROLES]) {
         const existing = seen.get(role.filename);
         if (existing)
             throw new Error(`duplicate managed agent role filename: ${role.filename} for ${existing} and ${role.id}`);
@@ -104,11 +455,63 @@ function role(id, filename, codexName, description, sandbox, aliases) {
         codex_name: codexName,
         description,
         sandbox,
-        permission_profile: sandbox === 'read-only' ? 'sks-readonly' : 'sks-workspace-write',
-        legacy_sandbox_projection: sandbox,
         required_for: ['codex-native-runtime'],
         ownership_marker: MANAGED_ASSET_MARKER,
         schema_version: MANAGED_ASSET_SCHEMA_VERSION
     };
 }
+function officialSubagentRole(input) {
+    return {
+        id: input.id,
+        filename: input.filename,
+        aliases: input.aliases,
+        codex_name: input.codexName,
+        description: input.description,
+        model: input.model,
+        model_reasoning_effort: 'max',
+        ...(input.sandbox ? { sandbox: input.sandbox } : {}),
+        nickname_candidates: input.nicknames,
+        selection_keywords: input.keywords,
+        developer_instructions: input.instructions,
+        required_for: ['codex-official-subagent-workflow'],
+        ownership_marker: MANAGED_OFFICIAL_SUBAGENT_MARKER,
+        schema_version: MANAGED_ASSET_SCHEMA_VERSION
+    };
+}
+function managedLegacyAgentRoleVariants(role) {
+    const base = [
+        `# ${MANAGED_ASSET_MARKER}`,
+        `# sks_managed_schema = ${role.schema_version}`,
+        `# sks_managed_id = "${role.id}"`,
+        '# sks_managed_version = "<legacy-version>"',
+        `name = "${role.codex_name}"`,
+        `description = "${role.description}"`
+    ];
+    const instructions = [
+        'developer_instructions = """',
+        `You are the SKS ${role.id} role.`,
+        role.sandbox === 'read-only' ? 'Do not edit files.' : 'Only edit the bounded files assigned by the parent orchestrator.',
+        'Return concise source-backed findings and LIVE_EVENT lines when applicable.',
+        '"""',
+        ''
+    ];
+    const legacyPolicy = [
+        `sandbox_mode = "${role.sandbox}"`,
+        `permission_profile = "${role.sandbox === 'read-only' ? 'sks-readonly' : 'sks-workspace-write'}"`,
+        `legacy_sandbox_projection = "${role.sandbox}"`
+    ];
+    return [
+        [...base, `sandbox_mode = "${role.sandbox}"`, ...instructions].join('\n'),
+        [...base, ...legacyPolicy, ...instructions].join('\n'),
+        [...base, 'model = "gpt-5.5"', 'model_reasoning_effort = "medium"', ...legacyPolicy, ...instructions].join('\n'),
+        [...base, 'model = "gpt-5.6-terra"', 'model_reasoning_effort = "high"', ...legacyPolicy, ...instructions].join('\n')
+    ];
+}
+function normalizeManagedLegacyAgentText(text) {
+    return String(text || '')
+        .replace(/\r\n?/g, '\n')
+        .replace(/^#\s*sks_managed_version\s*=\s*"[^"]+"\s*$/m, '# sks_managed_version = "<legacy-version>"')
+        .trimEnd()
+        .concat('\n');
+}
 //# sourceMappingURL=managed-assets-manifest.js.map

package/dist/core/mission.js

@@ -21,6 +21,9 @@ export function stateFileForSession(root, sessionKey) {
     return path.join(stateSessionsDir(root), `${sessionStateKey(sessionKey)}.json`);
 }
 export async function createMission(root, { mode, prompt, sessionKey }) {
+    return withStateLock(root, () => createMissionUnlocked(root, { mode, prompt, sessionKey }));
+}
+async function createMissionUnlocked(root, { mode, prompt, sessionKey }) {
     const id = missionId();
     const dir = missionDir(root, id);
     await ensureDir(dir);
@@ -38,9 +41,26 @@ export async function createMission(root, { mode, prompt, sessionKey }) {
     };
     await writeJsonAtomic(path.join(dir, 'mission.json'), mission);
     await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'mission.created', mission: id, mode, prompt });
-    await setCurrent(root, { mission_id: id, mode: mode.toUpperCase(), phase: mission.phase }, { replace: true, sessionKey });
+    await setCurrentUnlocked(root, { mission_id: id, mode: mode.toUpperCase(), phase: mission.phase }, { replace: true, sessionKey });
     return { id, dir, mission };
 }
+export async function getOrCreateSessionMission(root, input) {
+    return withStateLock(root, async () => {
+        const state = await loadStateForSessionUnlocked(root, input.sessionKey);
+        const selectedMissionId = String(input.selectMissionId(state) || '').trim();
+        if (selectedMissionId) {
+            const loaded = await loadMission(root, selectedMissionId).catch(() => null);
+            if (loaded)
+                return { ...loaded, reused: true };
+        }
+        const created = await createMissionUnlocked(root, {
+            mode: input.mode,
+            prompt: input.prompt,
+            sessionKey: input.sessionKey
+        });
+        return { ...created, reused: false };
+    });
+}
 export async function loadMission(root, id) {
     const dir = missionDir(root, id);
     const mission = await readJson(path.join(dir, 'mission.json'));
@@ -200,6 +220,9 @@ function routePreemptions(current = {}, patch = {}, opts = {}) {
     return [row, ...(Array.isArray(current?.preempted_missions) ? current.preempted_missions : [])].slice(0, 25);
 }
 export async function loadStateForSession(root, sessionKey) {
+    return loadStateForSessionUnlocked(root, sessionKey);
+}
+async function loadStateForSessionUnlocked(root, sessionKey) {
     const hashed = sessionStateKey(sessionKey || 'default');
     const file = path.join(stateSessionsDir(root), `${hashed}.json`);
     const sessionState = await readJson(file, null).catch(() => null);

package/dist/core/naruto/naruto-work-graph.js

@@ -38,6 +38,8 @@ export function buildNarutoWorkGraph(input = {}) {
     const basePath = normalizeNarutoPath(input.leaseBasePath || '.sneakoscope/naruto/patch-envelopes');
     const targetPaths = normalizePaths(input.targetPaths || []);
     const readonlyPaths = normalizePaths(input.readonlyPaths || []);
+    const readonlyPathPool = normalizePaths([...readonlyPaths, ...targetPaths]);
+    const promptScopes = writeCapable ? [] : extractNarutoPromptScopes(input.prompt || '', totalWorkItems);
     const worktreePolicy = input.worktreePolicy || {
         mode: 'patch-envelope-only',
         required: false,
@@ -60,9 +62,13 @@ export function buildNarutoWorkGraph(input = {}) {
             ? deliveryKind
             : baseKind;
         const kindWrites = writeCapable && isNarutoWriteKind(kind);
-        const selectedTarget = targetPaths.length ? targetPaths[index % targetPaths.length] || targetPaths[0] || '' : `${basePath}/${id}.json`;
+        const selectedTarget = writeCapable
+            ? targetPaths.length ? targetPaths[index % targetPaths.length] || targetPaths[0] || '' : `${basePath}/${id}.json`
+            : '';
         const writePaths = kindWrites ? [selectedTarget].filter(Boolean) : [];
-        const readPaths = readonlyPaths.length ? readonlyPaths : targetPaths.filter((item) => !writePaths.includes(item));
+        const readPaths = writeCapable
+            ? readonlyPaths.length ? readonlyPaths : targetPaths.filter((item) => !writePaths.includes(item))
+            : distributeReadonlyPaths(readonlyPathPool, index, totalWorkItems);
         const leaseRequirements = [
             ...writePaths.map((file) => ({ path: file, kind: 'write' })),
             ...readPaths.map((file) => ({ path: file, kind: 'read' }))
@@ -72,8 +78,10 @@ export function buildNarutoWorkGraph(input = {}) {
         workItems.push({
             id,
             kind,
-            title: titleForKind(kind, id),
-            target_paths: [...new Set([...(writePaths.length ? writePaths : [selectedTarget].filter(Boolean)), ...readPaths])],
+            title: promptScopes[index] ? titleForScope(promptScopes[index], index) : titleForKind(kind, id),
+            target_paths: writeCapable
+                ? [...new Set([...(writePaths.length ? writePaths : [selectedTarget].filter(Boolean)), ...readPaths])]
+                : readPaths,
             readonly_paths: readPaths,
             write_paths: writePaths,
             required_role: mapWorkKindToNarutoRole(kind),
@@ -224,6 +232,58 @@ function estimateCost(kind) {
 function titleForKind(kind, id) {
     return `${id} ${kind.replace(/_/g, ' ')}`;
 }
+function titleForScope(scope, index) {
+    const compact = String(scope || '').replace(/\s+/g, ' ').trim().slice(0, 220);
+    return `Scope ${index + 1}: ${compact}`;
+}
+export function extractNarutoPromptScopes(prompt, maxItems) {
+    const limit = Math.max(1, normalizePositiveInt(maxItems, 1));
+    const text = String(prompt || '').replace(/\r/g, '').trim();
+    if (!text)
+        return [];
+    const label = /(?:^|\s)(?:(?:five|\d+)\s+(?:independent\s+)?slices?|다섯\s*(?:개(?:의)?)?\s*(?:독립\s*)?(?:슬라이스|영역|항목))\s*:\s*/i.exec(text);
+    let source = label ? text.slice((label.index || 0) + label[0].length) : text;
+    const numbered = (source.match(/(?:^|[\s;])\d{1,2}[.):]\s+/g) || []).length >= 2;
+    const bulleted = (source.match(/^\s*[-*•]\s+/gm) || []).length >= 2;
+    const semicolonDelimited = source.includes(';');
+    if (!label && !numbered && !bulleted && !semicolonDelimited)
+        return [];
+    if (!label && numbered) {
+        const firstMarker = /(?:^|[\s;])\d{1,2}[.):]\s+/.exec(source);
+        if (firstMarker)
+            source = source.slice(firstMarker.index);
+    }
+    else if (!label && bulleted) {
+        const firstBullet = /^\s*[-*•]\s+/m.exec(source);
+        if (firstBullet)
+            source = source.slice(firstBullet.index);
+    }
+    const normalized = source.replace(/\s+(?=\d{1,2}[.):]\s+)/g, '\n');
+    const scopes = [];
+    const seen = new Set();
+    for (const raw of normalized.split(/[;\n]+/)) {
+        const scope = stripNarutoScopeInstructionTail(raw
+            .replace(/^\s*(?:[-*•]\s+|\d{1,2}[.):]\s*)/, '')
+            .replace(/[;\s]+$/, '')
+            .replace(/\s+/g, ' ')
+            .trim())
+            .replace(/[.!?。！？]+$/, '')
+            .trim();
+        const key = scope.toLowerCase();
+        if (!scope || seen.has(key))
+            continue;
+        seen.add(key);
+        scopes.push(scope);
+        if (scopes.length >= limit)
+            break;
+    }
+    return scopes;
+}
+function stripNarutoScopeInstructionTail(text) {
+    const sentences = String(text || '').split(/(?<=[.!?。！？])\s+/).map((part) => part.trim()).filter(Boolean);
+    const instructionIndex = sentences.findIndex((sentence, index) => index > 0 && /^(?:inspect|review|check|verify|use|do\s+not|never|return|report|limit|only|검사|검토|확인|검증|사용|수정하지|실행하지|반환|보고|제한)/i.test(sentence));
+    return (instructionIndex < 0 ? text : sentences.slice(0, instructionIndex).join(' ')).trim();
+}
 function normalizePositiveInt(value, fallback) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed) || parsed < 1)
@@ -233,4 +293,10 @@ function normalizePositiveInt(value, fallback) {
 function normalizePaths(paths) {
     return [...new Set(paths.map(normalizeNarutoPath).filter(Boolean))];
 }
+function distributeReadonlyPaths(paths, index, totalItems) {
+    if (!paths.length)
+        return [];
+    const assigned = paths.filter((_path, pathIndex) => pathIndex % Math.max(1, totalItems) === index);
+    return assigned.length ? assigned : [paths[index % paths.length]];
+}
 //# sourceMappingURL=naruto-work-graph.js.map

package/dist/core/ops/reporting.js

@@ -7,6 +7,9 @@ export async function writeOpsReport(root, fileName, report) {
     if (report.ok === true && report.blockers.length > 0) {
         throw new Error(`invalid ops report: ok true with blockers in ${fileName}`);
     }
+    if (!/^[A-Za-z0-9._-]+\.json$/.test(fileName) || path.basename(fileName) !== fileName) {
+        throw new Error(`invalid ops report file name: ${fileName}`);
+    }
     const reportPath = path.join(root, '.sneakoscope', 'reports', fileName);
     await fs.mkdir(path.dirname(reportPath), { recursive: true });
     await fs.writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');