sneakoscope 6.2.0 → 6.4.0

package/dist/core/mad-db/mad-db-ledger.js

@@ -1,37 +0,0 @@
-import path from 'node:path';
-import { appendJsonlBounded, nowIso, writeJsonAtomic } from '../fsx.js';
-import { missionDir } from '../mission.js';
-export const MAD_DB_LEDGER_EVENT_SCHEMA = 'sks.mad-db-ledger-event.v1';
-export async function appendMadDbLedgerEvent(root, missionId, event) {
-    const row = {
-        schema: MAD_DB_LEDGER_EVENT_SCHEMA,
-        ts: nowIso(),
-        mission_id: missionId,
-        ...event
-    };
-    const dir = missionDir(root, missionId);
-    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), row);
-    // The authoritative append above already succeeded or threw; this is a
-    // convenience "latest" pointer only. Its failure used to vanish silently
-    // (20차 P1-7) — readers of mad-db-ledger.latest.json could see a stale
-    // pointer with no signal anything was wrong.
-    await writeJsonAtomic(path.join(dir, 'mad-db-ledger.latest.json'), row).catch((err) => {
-        console.error(`mad-db-ledger: failed to update latest pointer for mission ${missionId}: ${err instanceof Error ? err.message : String(err)}`);
-    });
-    return row;
-}
-export async function appendMadDbOperationLifecycle(root, missionId, input) {
-    return appendMadDbLedgerEvent(root, missionId, {
-        type: input.type,
-        operation_id: input.operationId,
-        cycle_id: input.cycleId || null,
-        mcp_server: input.mcpServer || null,
-        tool_name: input.toolName || null,
-        sql_hash: input.sqlHash || null,
-        destructive: input.destructive === true,
-        result_status: input.resultStatus || 'pending_tool_result',
-        row_count: input.rowCount ?? null,
-        error: input.error || null
-    });
-}
-//# sourceMappingURL=mad-db-ledger.js.map

package/dist/core/mad-db/mad-db-policy-resolver.js

@@ -1,128 +0,0 @@
-import { isMadDbCapabilityActive, readMadDbCapability } from './mad-db-capability.js';
-import { activeMadDbAllowsSqlPlane, isMadDbControlPlaneDeniedTool, madDbOperationClassesFromClassification } from './mad-db-policy.js';
-import { readJson, sha256 } from '../fsx.js';
-import { missionsDir, stateFile } from '../mission.js';
-export const MAD_DB_POLICY_DECISION_SCHEMA = 'sks.mad-db-policy-decision.v2';
-export async function resolveMadDbMutationPolicy(root, state = {}, classification = {}, explicitCapability) {
-    const primary = await resolveMadDbMutationPolicyForState(root, state, classification, explicitCapability);
-    if (primary.allowed === true || explicitCapability)
-        return primary;
-    /* intentional: optional fallback lookup — primary policy already resolved, this only widens the search */
-    const persistedState = await readJson(stateFile(root), null).catch(() => null);
-    if (persistedState && persistedState !== state) {
-        const fallback = await resolveMadDbMutationPolicyForState(root, persistedState, classification, null);
-        if (fallback.allowed === true) {
-            return {
-                ...fallback,
-                state_source: 'persisted_sks_state',
-                reasons: [...fallback.reasons, 'mad_db_persisted_state_binding_used']
-            };
-        }
-    }
-    const latestCapability = await findLatestActiveMadDbCapability(root);
-    if (latestCapability) {
-        const fallback = await resolveMadDbMutationPolicyForState(root, {
-            mad_db_active: true,
-            mad_db_capability_mission_id: latestCapability.mission_id
-        }, classification, latestCapability);
-        if (fallback.allowed === true) {
-            return {
-                ...fallback,
-                state_source: 'latest_active_mad_db_capability',
-                reasons: [...fallback.reasons, 'mad_db_latest_active_capability_used']
-            };
-        }
-    }
-    return primary;
-}
-async function findLatestActiveMadDbCapability(root) {
-    const fs = await import('node:fs/promises');
-    const entries = await fs.readdir(missionsDir(root), { withFileTypes: true }).catch(() => []);
-    const candidates = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory() || !entry.name.startsWith('M-'))
-            continue;
-        /* intentional: scanning candidate mission dirs for an active capability — a missing/corrupt one is just not a candidate */
-        const capability = await readMadDbCapability(root, entry.name).catch(() => null);
-        if (!capability || !isMadDbCapabilityActive(capability))
-            continue;
-        const issuedMs = Date.parse(capability.issued_at || '');
-        const expiresMs = Date.parse(capability.expires_at || '');
-        candidates.push({
-            capability,
-            issuedMs: Number.isFinite(issuedMs) ? issuedMs : 0,
-            expiresMs: Number.isFinite(expiresMs) ? expiresMs : 0
-        });
-    }
-    candidates.sort((a, b) => ((a.issuedMs - b.issuedMs)
-        || (a.expiresMs - b.expiresMs)
-        || a.capability.mission_id.localeCompare(b.capability.mission_id)));
-    return candidates.at(-1)?.capability || null;
-}
-async function resolveMadDbMutationPolicyForState(root, state = {}, classification = {}, explicitCapability) {
-    const missionId = explicitCapability?.mission_id || state?.mad_db_capability_mission_id || state?.mission_id;
-    if (!missionId)
-        return inactive('mission_id_missing');
-    const capability = explicitCapability || await readMadDbCapability(root, String(missionId));
-    const validation = validateCapabilityBinding(capability, state, classification);
-    if (!validation.ok)
-        return inactive(validation.reason);
-    if (isMadDbControlPlaneDeniedTool(classification.toolName || classification.tool_name))
-        return inactive('mad_db_control_plane_tool_denied');
-    if (!activeMadDbAllowsSqlPlane(classification))
-        return inactive('not_a_database_sql_plane_mutation');
-    return {
-        schema: MAD_DB_POLICY_DECISION_SCHEMA,
-        allowed: true,
-        action: 'allow',
-        mode: 'mad-db-sql-plane-active',
-        priority: 0,
-        priority_order: ['mad-db', 'mad-sks', 'sealed-contract', 'default-db-safety'],
-        reasons: ['mad_db_capability_v2_bound_sql_plane_authorized'],
-        audit_required: true,
-        mission_id: capability.mission_id,
-        cycle_id: capability.cycle_id,
-        runtime_session_id: capability.runtime_session_id,
-        project_ref_hash: hashRef(capability.project_ref),
-        operation_classes: madDbOperationClassesFromClassification(classification),
-        counters: capability.counters,
-        capability
-    };
-}
-export function validateCapabilityBinding(capability, state = {}, classification = {}) {
-    if (!capability)
-        return { ok: false, reason: 'mad_db_capability_missing' };
-    if (!isMadDbCapabilityActive(capability))
-        return { ok: false, reason: `mad_db_capability_${capability.status || 'inactive'}` };
-    if (!capability.project_ref)
-        return { ok: false, reason: 'mad_db_project_ref_missing' };
-    const boundMadDbMissionId = state?.mad_db_capability_mission_id ? String(state.mad_db_capability_mission_id) : null;
-    if (boundMadDbMissionId === capability.mission_id && state?.mad_db_active === false)
-        return { ok: false, reason: 'mad_db_state_inactive' };
-    if (state?.mission_id && String(state.mission_id) !== capability.mission_id && boundMadDbMissionId !== capability.mission_id)
-        return { ok: false, reason: 'mad_db_mission_binding_mismatch' };
-    if (state?.mad_db_cycle_id && String(state.mad_db_cycle_id) !== capability.cycle_id)
-        return { ok: false, reason: 'mad_db_cycle_binding_mismatch' };
-    if (state?.mad_db_runtime_session_id && String(state.mad_db_runtime_session_id) !== capability.runtime_session_id)
-        return { ok: false, reason: 'mad_db_runtime_session_binding_mismatch' };
-    if (state?.mad_db_profile_sha256 && String(state.mad_db_profile_sha256) !== capability.transport.profile_sha256)
-        return { ok: false, reason: 'mad_db_profile_hash_mismatch' };
-    if (classification.toolReasons?.includes?.('dangerous_supabase_management_tool'))
-        return { ok: false, reason: 'mad_db_control_plane_tool_denied' };
-    return { ok: true, reason: 'ok' };
-}
-function inactive(reason) {
-    return {
-        schema: MAD_DB_POLICY_DECISION_SCHEMA,
-        allowed: false,
-        action: 'defer',
-        mode: 'default-db-safety',
-        priority: 99,
-        reasons: [reason],
-        audit_required: false
-    };
-}
-function hashRef(projectRef) {
-    return sha256(projectRef).slice(0, 16);
-}
-//# sourceMappingURL=mad-db-policy-resolver.js.map

package/dist/core/pipeline/route-prep-team.js

@@ -1,2 +0,0 @@
-export { prepareRoute } from './route-prep.js';
-//# sourceMappingURL=route-prep-team.js.map

package/dist/core/team-dag.js

@@ -1,58 +0,0 @@
-import path from 'node:path';
-import { exists, readJson } from './fsx.js';
-export const TEAM_GRAPH_ARTIFACT = 'team-graph.json';
-export const TEAM_RUNTIME_TASKS_ARTIFACT = 'team-runtime-tasks.json';
-export const TEAM_DECOMPOSITION_ARTIFACT = 'team-decomposition-report.json';
-export const TEAM_INBOX_DIR = 'team-inbox';
-export function teamRuntimeRequiredArtifacts() {
-    return [TEAM_GRAPH_ARTIFACT, TEAM_RUNTIME_TASKS_ARTIFACT, TEAM_DECOMPOSITION_ARTIFACT, TEAM_INBOX_DIR];
-}
-export function teamRuntimePlanMetadata() {
-    return {
-        schema_version: 1,
-        legacy_observe_only: true,
-        graph_artifact: TEAM_GRAPH_ARTIFACT,
-        runtime_tasks_artifact: TEAM_RUNTIME_TASKS_ARTIFACT,
-        decomposition_artifact: TEAM_DECOMPOSITION_ARTIFACT,
-        inbox_dir: TEAM_INBOX_DIR
-    };
-}
-export async function validateTeamRuntimeArtifacts(dir) {
-    const issues = [];
-    const graph = await readJson(path.join(dir, TEAM_GRAPH_ARTIFACT), null);
-    const runtime = await readJson(path.join(dir, TEAM_RUNTIME_TASKS_ARTIFACT), null);
-    const report = await readJson(path.join(dir, TEAM_DECOMPOSITION_ARTIFACT), null);
-    const inboxRoot = path.join(dir, TEAM_INBOX_DIR);
-    if (!graph)
-        issues.push(TEAM_GRAPH_ARTIFACT);
-    if (!runtime)
-        issues.push(TEAM_RUNTIME_TASKS_ARTIFACT);
-    if (!report)
-        issues.push(TEAM_DECOMPOSITION_ARTIFACT);
-    if (!(await exists(inboxRoot)))
-        issues.push(TEAM_INBOX_DIR);
-    if (!runtime?.tasks?.length)
-        issues.push(`${TEAM_RUNTIME_TASKS_ARTIFACT}:tasks`);
-    const ids = new Set((runtime?.tasks || []).map((task) => task.task_id));
-    for (const task of runtime?.tasks || []) {
-        if (!String(task.task_id || '').startsWith('task-'))
-            issues.push(`${task.task_id || 'task'}:task_id`);
-        for (const dep of [...(task.depends_on || []), ...(task.blocked_by || [])]) {
-            if (!ids.has(dep))
-                issues.push(`${task.task_id}:dependency:${dep}`);
-            if (!String(dep).startsWith('task-'))
-                issues.push(`${task.task_id}:symbolic_dependency:${dep}`);
-        }
-        if (!task.worker)
-            issues.push(`${task.task_id}:worker`);
-    }
-    for (const worker of Array.isArray(report?.inboxes) ? report.inboxes : []) {
-        const name = String(worker || 'worker').replace(/[^A-Za-z0-9_.-]+/g, '_');
-        if (!(await exists(path.join(inboxRoot, `${name}.md`))))
-            issues.push(`${TEAM_INBOX_DIR}:${worker}`);
-    }
-    if (Array.isArray(report?.write_scope_conflicts) && report.write_scope_conflicts.length > 0)
-        issues.push(`${TEAM_DECOMPOSITION_ARTIFACT}:write_scope_conflicts`);
-    return { ok: issues.length === 0, issues, graph, runtime, report };
-}
-//# sourceMappingURL=team-dag.js.map

package/dist/core/team-dashboard-renderer.js

@@ -1,23 +0,0 @@
-export const TEAM_DASHBOARD_PANES = ['Legacy Team Observation'];
-export async function buildTeamDashboardState(_dir, opts = {}) {
-    return {
-        schema_version: 1,
-        legacy_observe_only: true,
-        mission: { id: opts.missionId || 'unknown', route: 'team', phase: 'legacy_observe' },
-        panes: TEAM_DASHBOARD_PANES,
-        gates: [],
-        agents: [],
-        tasks: []
-    };
-}
-export async function writeTeamDashboardState(dir, opts = {}) {
-    const { writeJsonAtomic } = await import('./fsx.js');
-    const { ARTIFACT_FILES } = await import('./artifact-schemas.js');
-    const state = await buildTeamDashboardState(dir, opts);
-    await writeJsonAtomic(`${dir}/${ARTIFACT_FILES.team_dashboard_state}`, state);
-    return { ok: true, state };
-}
-export function renderTeamDashboardState(state = {}) {
-    return `Mission: ${state.mission?.id || 'unknown'} (${state.mission?.route || 'team'})\nPhase: ${state.mission?.phase || 'legacy_observe'}`;
-}
-//# sourceMappingURL=team-dashboard-renderer.js.map

package/dist/core/team-live.js

@@ -1,167 +0,0 @@
-import { MAX_AGENT_COUNT } from './agents/agent-schema.js';
-import { MIN_TEAM_REVIEWER_LANES } from './team-review-policy.js';
-export { MIN_TEAM_REVIEWER_LANES, MIN_TEAM_REVIEW_POLICY_TEXT, MIN_TEAM_REVIEW_STAGE_AGENT_SESSIONS, evaluateTeamReviewPolicyGate, teamReviewPolicy } from './team-review-policy.js';
-export const DEFAULT_TEAM_ROLE_COUNTS = { user: 1, planner: 1, reviewer: MIN_TEAM_REVIEWER_LANES, executor: 3 };
-export const MAX_TEAM_AGENT_SESSIONS = MAX_AGENT_COUNT;
-export const DEFAULT_MAX_TEAM_AGENT_SESSIONS = MAX_TEAM_AGENT_SESSIONS;
-const ROLE_ALIASES = {
-    user: 'user',
-    users: 'user',
-    customer: 'user',
-    client: 'user',
-    planner: 'planner',
-    planners: 'planner',
-    architect: 'planner',
-    lead: 'planner',
-    executor: 'executor',
-    executors: 'executor',
-    implementer: 'executor',
-    developer: 'executor',
-    dev: 'executor',
-    reviewer: 'reviewer',
-    reviewers: 'reviewer',
-    critic: 'reviewer',
-    qa: 'reviewer',
-    verifier: 'reviewer'
-};
-export function normalizeTeamAgentSessions(value, fallback = 3) {
-    const n = Number(value ?? fallback);
-    const fallbackNumber = Number(fallback);
-    const fallbackCount = Number.isFinite(fallbackNumber) ? Math.floor(fallbackNumber) : 3;
-    return Math.min(MAX_TEAM_AGENT_SESSIONS, Math.max(1, Number.isFinite(n) ? Math.floor(n) : fallbackCount));
-}
-export function parseTeamSpecArgs(args = []) {
-    const cleanArgs = [];
-    let roleCounts = { ...DEFAULT_TEAM_ROLE_COUNTS };
-    let explicitSession = null;
-    let explicitExecutor = false;
-    for (let i = 0; i < args.length; i++) {
-        const arg = String(args[i]);
-        const parsed = parseBudgetOrRoleToken(arg, roleCounts, explicitExecutor, explicitSession);
-        if (parsed.consumed) {
-            roleCounts = parsed.roleCounts;
-            explicitExecutor = parsed.explicitExecutor;
-            explicitSession = parsed.explicitSession;
-            continue;
-        }
-        if (/^--(?:agents|sessions|team-size)$/.test(arg)) {
-            explicitSession = normalizeTeamAgentSessions(args[i + 1]);
-            if (!explicitExecutor)
-                roleCounts.executor = explicitSession;
-            i++;
-            continue;
-        }
-        if (/^--(?:max-agents|max-sessions|max-team)$/.test(arg)) {
-            explicitSession = DEFAULT_MAX_TEAM_AGENT_SESSIONS;
-            if (!explicitExecutor)
-                roleCounts.executor = DEFAULT_MAX_TEAM_AGENT_SESSIONS;
-            continue;
-        }
-        if (/^--(?:work-items|target-active-slots|minimum-work-items|max-queue-expansion|ollama-model|local-model-model|ollama-base-url|local-model-base-url)$/.test(arg)) {
-            i++;
-            continue;
-        }
-        if (/^--(?:work-items|target-active-slots|minimum-work-items|max-queue-expansion)=/.test(arg))
-            continue;
-        if (/^--(?:ollama-model|local-model-model|ollama-base-url|local-model-base-url)=/.test(arg))
-            continue;
-        if (/^--(?:json|open-zellij|zellij-open|no-open-zellij|no-zellij|no-attach|separate-session|new-session|legacy-team-session|ollama|local-model|no-ollama|no-local-model)$/.test(arg))
-            continue;
-        const consumed = consumeTeamSpecText(arg, { roleCounts, explicitExecutor, explicitSession });
-        roleCounts = consumed.roleCounts;
-        explicitExecutor = consumed.explicitExecutor;
-        explicitSession = consumed.explicitSession;
-        if (consumed.prompt)
-            cleanArgs.push(consumed.prompt);
-    }
-    return { cleanArgs, ...normalizeTeamSpec({ roleCounts, agentSessions: explicitSession }) };
-}
-export function parseTeamSpecText(text = '') {
-    const wantsMaxAgents = /\b(max|maximum|maximal|available agents?)\b|최대|가용가능/i.test(String(text || ''));
-    const consumed = consumeTeamSpecText(text, { roleCounts: { ...DEFAULT_TEAM_ROLE_COUNTS }, explicitExecutor: false, explicitSession: null });
-    if (wantsMaxAgents && !consumed.explicitExecutor)
-        consumed.roleCounts.executor = DEFAULT_MAX_TEAM_AGENT_SESSIONS;
-    return {
-        prompt: consumed.prompt,
-        ...normalizeTeamSpec({
-            roleCounts: consumed.roleCounts,
-            agentSessions: consumed.explicitSession ?? (wantsMaxAgents ? consumed.roleCounts.executor : undefined),
-            prompt: consumed.prompt
-        })
-    };
-}
-export function normalizeTeamSpec(opts = {}) {
-    const roleCounts = normalizeTeamRoleCounts(opts.roleCounts);
-    if (opts.agentSessions !== undefined && (!opts.roleCounts || opts.roleCounts.executor === undefined)) {
-        roleCounts.executor = normalizeTeamAgentSessions(opts.agentSessions, roleCounts.executor);
-    }
-    const bundleSize = normalizeTeamAgentSessions(roleCounts.executor, DEFAULT_TEAM_ROLE_COUNTS.executor);
-    const agentSessions = Math.max(normalizeTeamAgentSessions(opts.agentSessions ?? bundleSize), normalizeTeamAgentSessions(roleCounts.reviewer, MIN_TEAM_REVIEWER_LANES));
-    return { agentSessions, bundleSize, roleCounts, roster: buildTeamRoster(roleCounts) };
-}
-export function normalizeTeamRoleCounts(input = {}) {
-    const counts = { ...DEFAULT_TEAM_ROLE_COUNTS };
-    for (const [key, value] of Object.entries(input || {})) {
-        const role = normalizeTeamRole(key);
-        if (role)
-            counts[role] = normalizeTeamAgentSessions(value, counts[role] || 1);
-    }
-    counts.reviewer = Math.max(MIN_TEAM_REVIEWER_LANES, counts.reviewer ?? 0);
-    return counts;
-}
-export function buildTeamRoster(roleCounts = DEFAULT_TEAM_ROLE_COUNTS) {
-    const counts = normalizeTeamRoleCounts(roleCounts);
-    const bundleSize = normalizeTeamAgentSessions(counts.executor);
-    const numbered = (prefix, count, role = prefix) => Array.from({ length: normalizeTeamAgentSessions(count, 1) }, (_, i) => ({ id: `${prefix}_${i + 1}`, role, index: i + 1 }));
-    const analysis = numbered('native_agent', bundleSize, 'analysis');
-    const debate = [...numbered('debate_user', counts.user, 'user'), ...numbered('debate_planner', counts.planner, 'planner'), ...numbered('debate_reviewer', counts.reviewer, 'reviewer'), ...numbered('debate_executor', bundleSize, 'executor')].slice(0, bundleSize);
-    const development = numbered('executor', bundleSize, 'executor');
-    const validation = [...numbered('reviewer', counts.reviewer, 'reviewer'), ...numbered('user', counts.user, 'user')];
-    return { role_counts: counts, bundle_size: bundleSize, analysis_team: analysis, debate_team: debate, development_team: development, validation_team: validation, all_agents: [...analysis, ...debate, ...development, ...validation] };
-}
-export function formatRoleCounts(roleCounts = DEFAULT_TEAM_ROLE_COUNTS) {
-    return Object.entries(normalizeTeamRoleCounts(roleCounts)).map(([role, count]) => `${role}:${count}`).join(' ');
-}
-function parseBudgetOrRoleToken(token, roleCounts, explicitExecutor, explicitSession) {
-    const state = { consumed: false, roleCounts, explicitExecutor, explicitSession };
-    const budget = token.match(/^(\d+):(agents?|sessions?|team)$/i);
-    if (budget) {
-        const count = normalizeTeamAgentSessions(budget[1], DEFAULT_TEAM_ROLE_COUNTS.executor);
-        if (!explicitExecutor)
-            state.roleCounts = { ...roleCounts, executor: count };
-        return { ...state, consumed: true, explicitSession: count };
-    }
-    const rolePair = token.match(/^(?:--)?([A-Za-z][A-Za-z_-]*)(?::|=)(\d+)$/);
-    const role = rolePair ? normalizeTeamRole(rolePair[1]) : null;
-    if (!rolePair || !role)
-        return state;
-    const count = normalizeTeamAgentSessions(rolePair[2], DEFAULT_TEAM_ROLE_COUNTS[role] || 1);
-    return { consumed: true, roleCounts: { ...roleCounts, [role]: count }, explicitExecutor: explicitExecutor || role === 'executor', explicitSession };
-}
-function consumeTeamSpecText(text, state) {
-    let roleCounts = { ...(state.roleCounts || DEFAULT_TEAM_ROLE_COUNTS) };
-    let explicitExecutor = state.explicitExecutor === true;
-    let explicitSession = state.explicitSession ?? null;
-    const prompt = String(text || '')
-        .replace(/\b(\d+):(agents?|sessions?|team)\b/gi, (token) => {
-        const parsed = parseBudgetOrRoleToken(token, roleCounts, explicitExecutor, explicitSession);
-        roleCounts = parsed.roleCounts;
-        explicitExecutor = parsed.explicitExecutor;
-        explicitSession = parsed.explicitSession;
-        return parsed.consumed ? '' : token;
-    })
-        .replace(/\b([A-Za-z][A-Za-z_-]*):(\d+)\b/g, (token) => {
-        const parsed = parseBudgetOrRoleToken(token, roleCounts, explicitExecutor, explicitSession);
-        roleCounts = parsed.roleCounts;
-        explicitExecutor = parsed.explicitExecutor;
-        explicitSession = parsed.explicitSession;
-        return parsed.consumed ? '' : token;
-    })
-        .replace(/\s+/g, ' ')
-        .trim();
-    return { prompt, roleCounts, explicitExecutor, explicitSession };
-}
-function normalizeTeamRole(role) {
-    return ROLE_ALIASES[String(role || '').trim().toLowerCase().replace(/[^a-z_-]/g, '')] || null;
-}
-//# sourceMappingURL=team-live.js.map

package/dist/core/team-review-policy.js

@@ -1,62 +0,0 @@
-export const MIN_TEAM_REVIEWER_LANES = 5;
-export const MIN_TEAM_REVIEW_STAGE_AGENT_SESSIONS = MIN_TEAM_REVIEWER_LANES;
-export const MIN_TEAM_REVIEW_POLICY_TEXT = `Minimum Team review policy: run at least ${MIN_TEAM_REVIEWER_LANES} independent reviewer/QA validation lanes before integration or final, even when the requested reviewer role count is lower.`;
-export const DEFAULT_OFFICIAL_REVIEWER_LANES = 1;
-export const MAX_AUTOMATIC_OFFICIAL_REVIEWER_LANES = 2;
-export const MAX_CRITICAL_OFFICIAL_REVIEWER_LANES = 3;
-export const OFFICIAL_SUBAGENT_REVIEW_POLICY_TEXT = 'Official subagent review policy: start with one focused reviewer, expand to two only for independent review domains, and use at most three automatic reviewers for critical multi-domain risk. The parent owns integration and may honor a larger explicit operator request.';
-export function officialSubagentReviewLaneBudget(input = {}) {
-    if (Number.isFinite(Number(input.explicit)) && Number(input.explicit) > 0) {
-        return { requested: Math.floor(Number(input.explicit)), source: 'explicit_operator' };
-    }
-    const domains = Math.max(0, Math.floor(Number(input.independentDomains || 0)));
-    const ceiling = input.critical === true ? MAX_CRITICAL_OFFICIAL_REVIEWER_LANES : MAX_AUTOMATIC_OFFICIAL_REVIEWER_LANES;
-    return {
-        requested: Math.max(DEFAULT_OFFICIAL_REVIEWER_LANES, Math.min(ceiling, domains || DEFAULT_OFFICIAL_REVIEWER_LANES)),
-        source: 'risk_scoped_automatic'
-    };
-}
-function numericCount(value, fallback = 0) {
-    const number = Number(value);
-    return Number.isFinite(number) ? Math.max(0, Math.floor(number)) : fallback;
-}
-export function teamReviewPolicy() {
-    return {
-        gate: 'team_review_policy',
-        minimum_reviewer_lanes: MIN_TEAM_REVIEWER_LANES,
-        minimum_review_stage_agent_sessions: MIN_TEAM_REVIEW_STAGE_AGENT_SESSIONS,
-        text: MIN_TEAM_REVIEW_POLICY_TEXT
-    };
-}
-export function teamValidationReviewerCount(roster = {}) {
-    const validation = Array.isArray(roster?.validation_team) ? roster.validation_team : [];
-    return validation.filter((agent) => {
-        const id = String(agent?.id || agent || '');
-        const role = String(agent?.role || '');
-        return /review|qa|validation/i.test(`${role} ${id}`);
-    }).length;
-}
-export function evaluateTeamReviewPolicyGate({ roleCounts = {}, agentSessions = 0, roster = {} } = {}) {
-    const requestedReviewerLanes = numericCount(roleCounts.reviewer);
-    const requiredReviewerLanes = Math.max(MIN_TEAM_REVIEWER_LANES, requestedReviewerLanes);
-    const validationReviewerLanes = teamValidationReviewerCount(roster);
-    const sessionCount = numericCount(agentSessions);
-    const blockers = [];
-    if (requestedReviewerLanes < MIN_TEAM_REVIEWER_LANES)
-        blockers.push('role_counts.reviewer_below_minimum');
-    if (validationReviewerLanes < requiredReviewerLanes)
-        blockers.push('validation_team_reviewers_below_required');
-    if (sessionCount < requiredReviewerLanes)
-        blockers.push('agent_sessions_below_review_required');
-    return {
-        gate: 'team_review_policy',
-        passed: blockers.length === 0,
-        blockers,
-        minimum_reviewer_lanes: MIN_TEAM_REVIEWER_LANES,
-        required_reviewer_lanes: requiredReviewerLanes,
-        requested_reviewer_lanes: requestedReviewerLanes,
-        validation_reviewer_lanes: validationReviewerLanes,
-        agent_sessions: sessionCount
-    };
-}
-//# sourceMappingURL=team-review-policy.js.map

package/dist/scripts/agent-ast-aware-work-graph-check.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root, readJson } from './sks-1-18-gate-lib.js';
-const inventoryMod = await importDist('core/agents/work-partition/repo-inventory.js');
-const depsMod = await importDist('core/agents/work-partition/dependency-graph.js');
-const graphMod = await importDist('core/agents/intelligent-work-graph.js');
-const inventory = await inventoryMod.collectRepoInventory(root, { maxFiles: 2000 });
-const dependencyGraph = depsMod.buildDependencyGraph(inventory);
-const graph = await graphMod.buildIntelligentWorkGraph({ root, inventory, dependencyGraph, route: '$Team', prompt: '1.18.6 AST-aware work graph release gate' });
-const releaseVersion = readJson('package.json').version;
-assertGate(graph.schema === 'sks.intelligent-work-graph.v2', 'intelligent work graph schema must be v2', graph);
-assertGate(graph.ast_coverage > 0, 'AST-aware work graph must record AST coverage', graph);
-assertGate(Object.keys(graph.file_to_symbols).length > 0, 'AST-aware work graph must build file-to-symbol map', graph);
-assertGate(Object.keys(graph.symbol_to_files).length > 0, 'AST-aware work graph must build symbol-to-file map', graph);
-assertGate(Object.keys(graph.exported_symbols).length > 0, 'AST-aware work graph must build exported symbol map', graph);
-assertGate(Object.keys(graph.imported_symbols).length > 0, 'AST-aware work graph must build imported symbol map', graph);
-assertGate(Object.keys(graph.command_to_module_ownership).length > 0, 'AST-aware work graph must build command ownership map', graph);
-assertGate(graph.test_ownership_confidence >= 0, 'AST-aware work graph must record test ownership confidence', graph);
-assertGate(['proven', 'partial', 'blocked'].includes(graph.proof_level), 'AST-aware work graph must report an honest proof level', graph);
-fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', `agent-intelligent-work-graph-v2-${releaseVersion}.json`), `${JSON.stringify(graphMod.compactIntelligentWorkGraph(graph), null, 2)}\n`);
-emitGate('agent:ast-aware-work-graph', { score: graph.work_graph_quality_score, ast_coverage: graph.ast_coverage, proof_level: graph.proof_level });
-//# sourceMappingURL=agent-ast-aware-work-graph-check.js.map

package/dist/scripts/agent-backfill-replenishment-check.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { runDynamicPoolFixture } from './agent-dynamic-pool-fixture.js';
-const fixture = await runDynamicPoolFixture({ target: 4, total: 8 });
-const backfills = fixture.events.filter((event) => event.event_type === 'backfill_event');
-const firstSlowCompletionIndex = fixture.events.findIndex((event) => event.event_type === 'session_completed' && /work-00[3-5]/.test(String(event.work_item_id || '')));
-const secondBackfillIndex = fixture.events.findIndex((event, index) => index > fixture.events.findIndex((row) => row.event_type === 'backfill_event') && event.event_type === 'backfill_event');
-assertGate(backfills.length >= 2, 'two early completions must create two backfill events', { backfills });
-assertGate(secondBackfillIndex >= 0 && (firstSlowCompletionIndex < 0 || secondBackfillIndex < firstSlowCompletionIndex), 'replacement sessions must launch before the remaining first wave drains', { firstSlowCompletionIndex, secondBackfillIndex });
-assertGate(fixture.result.state.backfill_count >= fixture.result.state.expected_backfill_count, 'backfill count must satisfy expected backfills', fixture.result.state);
-emitGate('agent:backfill-replenishment', { backfill_count: fixture.result.state.backfill_count, expected_backfill_count: fixture.result.state.expected_backfill_count });
-//# sourceMappingURL=agent-backfill-replenishment-check.js.map

package/dist/scripts/agent-background-terminals-check.js

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/agents/agent-terminal-session.js');
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-agent-terminal-'));
-await fs.writeFile(path.join(root, 'agent-sessions.json'), JSON.stringify({ schema: 'sks.agent-sessions.v1', sessions: { agent_1: { agent_id: 'agent_1', session_id: 's1', status: 'closed' } } }, null, 2));
-const agent = { id: 'agent_1', session_id: 's1' };
-await mod.startAgentTerminalSession(root, agent, { backend: 'fake', real: false });
-await mod.closeAgentTerminalSession(root, agent, { exitCode: 0, status: 'done' });
-const closed = await mod.assertAgentTerminalSessionsClosed(root);
-assertGate(closed.ok === true, 'every agent terminal session must have close report', closed);
-emitGate('agent:background-terminals', { terminal_sessions: closed.total_sessions });
-//# sourceMappingURL=agent-background-terminals-check.js.map

package/dist/scripts/agent-cleanup-command-ux-check.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const surface = await importDist('core/agents/agent-command-surface.js');
-const parsed = surface.parseAgentCommandArgs('agent', ['cleanup', 'latest', '--apply', '--dry-run', '--drain', '--stale-ms', '1234', '--json']);
-assertGate(parsed.action === 'cleanup', 'agent command parser must parse cleanup action', parsed);
-assertGate(parsed.apply === true, 'agent command parser must support --apply', parsed);
-assertGate(parsed.dryRun === true, 'agent command parser must support --dry-run', parsed);
-assertGate(parsed.drain === true, 'agent command parser must support --drain', parsed);
-assertGate(parsed.staleMs === 1234, 'agent command parser must support --stale-ms', parsed);
-emitGate('agent:cleanup-command-ux', { action: parsed.action, stale_ms: parsed.staleMs });
-//# sourceMappingURL=agent-cleanup-command-ux-check.js.map

package/dist/scripts/agent-cleanup-executor-check.js

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const cleanup = await importDist('core/agents/agent-cleanup-executor.js');
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-cleanup-executor-'));
-const missionDir = path.join(root, '.sneakoscope', 'missions', 'M-cleanup-fixture');
-const agentRoot = path.join(missionDir, 'agents');
-const projectHash = 'cleanupfixturehash';
-const tempDir = path.join(os.tmpdir(), `sks-${projectHash}-orphan`);
-const lockDir = path.join(os.tmpdir(), `sks-${projectHash}-locks`);
-await fs.mkdir(path.join(agentRoot, 'sessions', 'slot-001', 'gen-1'), { recursive: true });
-await fs.mkdir(tempDir, { recursive: true });
-await fs.mkdir(lockDir, { recursive: true });
-const lockFile = path.join(lockDir, 'stale.lock');
-await fs.writeFile(lockFile, 'stale\n');
-const staleTime = new Date(Date.now() - 60 * 60 * 1000);
-await fs.utimes(lockFile, staleTime, staleTime);
-await fs.writeFile(path.join(missionDir, 'project-session-namespace.json'), JSON.stringify({
-    schema: 'sks.project-session-namespace.v1',
-    mission_id: 'M-cleanup-fixture',
-    root_hash: projectHash,
-    orphan_temp_dirs: [tempDir, path.join(os.tmpdir(), 'foreign-temp')],
-    lock_dir: lockDir
-}, null, 2));
-await fs.writeFile(path.join(agentRoot, 'agent-sessions.json'), JSON.stringify({
-    sessions: {
-        active: { session_id: 'active-session', status: 'running' },
-        closed: { session_id: 'closed-session', status: 'closed' }
-    }
-}, null, 2));
-await fs.writeFile(path.join(agentRoot, 'sessions', 'slot-001', 'gen-1', 'agent-terminal-session.json'), '{}\n');
-const dry = await cleanup.runAgentCleanupExecutor({ missionDir, missionId: 'M-cleanup-fixture', action: 'cleanup', dryRun: true, staleMs: 1 });
-assertGate(dry.dry_run === true && dry.orphan_temp_dirs_found.includes(tempDir), 'cleanup dry-run must find orphan temp dir without applying', dry);
-assertGate(await exists(tempDir), 'cleanup dry-run removed temp dir unexpectedly', { tempDir });
-const applied = await cleanup.runAgentCleanupExecutor({ missionDir, missionId: 'M-cleanup-fixture', action: 'cleanup', apply: true, staleMs: 1 });
-assertGate(applied.ok === true, 'cleanup apply proof must pass', applied);
-assertGate(!(await exists(tempDir)), 'cleanup apply must remove namespaced orphan temp dir', applied);
-assertGate(!(await exists(lockFile)), 'cleanup apply must remove stale lock file', applied);
-assertGate(applied.terminal_transcripts_preserved.length === 1, 'cleanup must preserve terminal transcripts', applied);
-emitGate('agent:cleanup-executor', { removed_temp_dirs: applied.orphan_temp_dirs_removed.length, removed_locks: applied.stale_locks_removed.length });
-async function exists(file) {
-    try {
-        await fs.access(file);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=agent-cleanup-executor-check.js.map