sneakoscope 2.0.10 → 2.0.12

package/dist/core/naruto/naruto-allocation-policy.js

@@ -0,0 +1,99 @@
+import { extractNarutoTaskHints, pathPrefix } from './naruto-task-hints.js';
+export function chooseNarutoTaskOwner(task, workers, currentAssignments = [], leaseState = {}) {
+    if (!workers.length)
+        throw new Error('at least one Naruto worker is required');
+    const hints = extractNarutoTaskHints(task);
+    const activeWritePaths = new Set((leaseState.active_write_paths || []).map(String));
+    const completedTaskIds = new Set((leaseState.completed_task_ids || []).map(String));
+    const writeConflict = hints.writePaths.some((file) => activeWritePaths.has(file));
+    const dependencyIncomplete = task.dependencies.some((dep) => !completedTaskIds.has(dep));
+    const ranked = workers.map((worker, index) => {
+        const assigned = currentAssignments.filter((row) => row.owner === worker.id);
+        const assignedHints = assigned.map((row) => ({
+            role: row.role || null,
+            paths: row.paths || [],
+            domains: row.domains || [],
+            writePaths: row.write_paths || []
+        }));
+        const primaryRole = worker.primary_role || worker.role || null;
+        const declaredRoles = new Set([worker.role, ...(worker.declared_roles || [])].filter(Boolean).map(String));
+        const primaryRoleMatches = Boolean(hints.role && primaryRole === hints.role);
+        const declaredRoleMatches = Boolean(hints.role && declaredRoles.has(hints.role));
+        const assignmentRoleMatches = Boolean(hints.role && assigned.some((row) => row.role === hints.role));
+        const sameLane = samePathLane(hints.paths, assignedHints.flatMap((row) => row.paths));
+        const overlap = overlapCount(hints.paths, assignedHints.flatMap((row) => row.paths))
+            + overlapCount(hints.domains, assignedHints.flatMap((row) => row.domains));
+        const laneMatches = Boolean(worker.lane && hints.paths.some((file) => pathLaneMatches(file, String(worker.lane))));
+        const score = dependencyIncomplete
+            ? Number.NEGATIVE_INFINITY
+            : (primaryRoleMatches ? 18 : 0)
+                + (declaredRoleMatches ? 12 : 0)
+                + (sameLane || laneMatches ? 12 : 0)
+                + (overlap * 4)
+                - (assigned.length * 4)
+                - (writeConflict ? 20 : 0);
+        return { worker, index, assigned, score, overlap, primaryRoleMatches, declaredRoleMatches, assignmentRoleMatches, sameLane: sameLane || laneMatches, writeConflict, dependencyIncomplete };
+    }).sort((left, right) => {
+        if (right.score !== left.score)
+            return right.score - left.score;
+        if (right.overlap !== left.overlap)
+            return right.overlap - left.overlap;
+        if (left.assigned.length !== right.assigned.length)
+            return left.assigned.length - right.assigned.length;
+        return left.index - right.index;
+    });
+    const selected = ranked[0];
+    const reasons = [
+        selected.primaryRoleMatches ? 'same primary role' : null,
+        selected.declaredRoleMatches ? 'same declared role' : null,
+        selected.assignmentRoleMatches ? 'same assigned role history' : null,
+        selected.sameLane ? 'same path/domain lane' : null,
+        selected.overlap ? `overlap:${selected.overlap}` : null,
+        selected.writeConflict ? 'write lease conflict penalty applied' : null,
+        selected.dependencyIncomplete ? 'dependency incomplete' : null,
+        `load:${selected.assigned.length}`
+    ].filter(Boolean);
+    return {
+        owner: selected.worker.id,
+        score: selected.score,
+        reason: reasons.join('; '),
+        hints
+    };
+}
+export function allocateNarutoTasksToWorkers(tasks, workers) {
+    const assignments = [];
+    for (const task of tasks) {
+        const decision = chooseNarutoTaskOwner(task, workers, assignments.map((row) => ({
+            task_id: row.id,
+            owner: row.owner,
+            role: row.required_role,
+            paths: row.hints.paths,
+            domains: row.hints.domains,
+            write_paths: row.hints.writePaths
+        })), {
+            active_write_paths: assignments.flatMap((row) => row.hints.writePaths)
+        });
+        assignments.push({
+            ...task,
+            owner: decision.owner,
+            allocation_reason: decision.reason,
+            allocation_score: decision.score,
+            hints: decision.hints
+        });
+    }
+    return assignments;
+}
+function samePathLane(left, right) {
+    const prefixes = new Set(right.map(pathPrefix).filter(Boolean));
+    return left.some((file) => prefixes.has(pathPrefix(file)));
+}
+function pathLaneMatches(file, lane) {
+    const normalizedLane = lane.replace(/^\.\/+/, '').replace(/\/+$/, '');
+    const normalizedFile = file.replace(/^\.\/+/, '');
+    return pathPrefix(normalizedFile) === normalizedLane || normalizedFile === normalizedLane || normalizedFile.startsWith(`${normalizedLane}/`);
+}
+function overlapCount(left, right) {
+    const rightSet = new Set(right);
+    return left.filter((item) => rightSet.has(item)).length;
+}
+//# sourceMappingURL=naruto-allocation-policy.js.map

package/dist/core/naruto/naruto-real-worker-child.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import fs from 'node:fs/promises';
-import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import path from 'node:path';
+import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { runCodexTask } from '../codex-control/codex-control-plane.js';
+import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } from '../codex-control/schemas/agent-worker-result.schema.js';
 async function main() {
     const intakePath = process.argv[2];
     if (!intakePath)
@@ -15,16 +18,112 @@ async function main() {
         item_id: intake.item.id,
         status: 'running'
     })}\n`);
-    await new Promise((resolve) => setTimeout(resolve, 25));
-    await writeJsonAtomic(intake.result_path, {
-        schema: 'sks.naruto-actual-worker-result.v1',
-        ok: true,
-        generated_at: nowIso(),
-        item_id: intake.item.id,
-        placement: intake.placement,
-        backend: intake.backend,
-        worktree_path: intake.worktree_path
-    });
+    if (intake.backend === 'fake')
+        process.env.SKS_CODEX_SDK_FAKE = '1';
+    const controlRoot = path.join(path.dirname(intake.result_path), 'codex-control');
+    await ensureDir(controlRoot);
+    try {
+        const taskResult = await runCodexTask({
+            route: '$Naruto',
+            tier: 'worker',
+            missionId: String(intake.mission_id || ''),
+            workItemId: String(intake.item.id || ''),
+            slotId: String(intake.item.id || ''),
+            generationIndex: 1,
+            sessionId: String(intake.item.id || ''),
+            cwd: String(intake.worktree_path || process.cwd()),
+            prompt: buildNarutoWorkerPrompt(intake.item),
+            outputSchemaId: CODEX_AGENT_WORKER_RESULT_SCHEMA_ID,
+            outputSchema: codexAgentWorkerResultSchema,
+            sandboxPolicy: intake.item.write_allowed === true ? 'workspace-write' : 'read-only',
+            requestedScopeContract: {
+                id: `naruto:${intake.item.id}`,
+                route: '$Naruto',
+                read_only: intake.item.write_allowed !== true,
+                allowed_paths: [...new Set([...(intake.item.target_paths || []), ...(intake.item.readonly_paths || []), ...(intake.item.write_paths || [])].map(String))],
+                write_paths: Array.isArray(intake.item.write_paths) ? intake.item.write_paths.map(String) : [],
+                user_confirmed_full_access: false,
+                mad_sks_authorized: false
+            },
+            backendPreference: backendPreference(intake.backend),
+            allowLocalLlm: intake.backend === 'ollama' || intake.backend === 'local-llm',
+            ...(intake.backend === 'ollama' || intake.backend === 'local-llm' ? { localLlmPolicy: { mode: 'local_preferred', requiresGptFinal: true } } : {}),
+            mutationLedgerRoot: controlRoot,
+            reliabilityPolicy: {
+                maxEmptyResultRetries: 1,
+                timeoutClass: 'short'
+            }
+        });
+        const workerResult = await readJson(taskResult.workerResultPath, null);
+        const blockers = [...(taskResult.blockers || []), ...(Array.isArray(workerResult?.blockers) ? workerResult.blockers : [])];
+        await writeJsonAtomic(intake.result_path, {
+            schema: 'sks.naruto-actual-worker-result.v1',
+            ok: taskResult.ok === true && blockers.length === 0,
+            generated_at: nowIso(),
+            item_id: intake.item.id,
+            placement: intake.placement,
+            backend: taskResult.backend,
+            backend_family: taskResult.backend_family,
+            worktree_path: intake.worktree_path,
+            control_plane_result: {
+                worker_result_path: taskResult.workerResultPath,
+                patch_envelope_path: taskResult.patchEnvelopePath || null,
+                stream_event_count: taskResult.streamEventCount,
+                structured_output_valid: taskResult.structuredOutputValid,
+                sdk_thread_id: taskResult.sdkThreadId,
+                sdk_run_id: taskResult.sdkRunId || null
+            },
+            changed_files: Array.isArray(workerResult?.changed_files) ? workerResult.changed_files : [],
+            blockers
+        });
+        await fs.appendFile(intake.heartbeat_path, `${JSON.stringify({
+            schema: 'sks.naruto-actual-worker-heartbeat.v1',
+            ts: nowIso(),
+            item_id: intake.item.id,
+            status: blockers.length ? 'blocked' : 'done'
+        })}\n`);
+    }
+    catch (err) {
+        await writeJsonAtomic(intake.result_path, {
+            schema: 'sks.naruto-actual-worker-result.v1',
+            ok: false,
+            generated_at: nowIso(),
+            item_id: intake.item.id,
+            placement: intake.placement,
+            backend: intake.backend,
+            worktree_path: intake.worktree_path,
+            blockers: [`naruto_actual_worker_control_plane_exception:${err?.message || String(err)}`]
+        });
+        await fs.appendFile(intake.heartbeat_path, `${JSON.stringify({
+            schema: 'sks.naruto-actual-worker-heartbeat.v1',
+            ts: nowIso(),
+            item_id: intake.item.id,
+            status: 'blocked'
+        })}\n`);
+        throw err;
+    }
+}
+function backendPreference(value) {
+    const backend = String(value || '');
+    if (backend === 'ollama' || backend === 'local-llm')
+        return ['local-llm', 'codex-sdk'];
+    return ['codex-sdk'];
+}
+function buildNarutoWorkerPrompt(item) {
+    const writeAllowed = item?.write_allowed === true;
+    return [
+        'You are a Naruto route worker. Complete only this assigned work item and return JSON matching the required schema.',
+        `Work item: ${String(item?.id || '')} ${String(item?.title || item?.kind || '')}`,
+        `Role: ${String(item?.required_role || 'worker')}`,
+        `Kind: ${String(item?.kind || 'verification')}`,
+        `Target paths: ${JSON.stringify(item?.target_paths || [])}`,
+        `Readonly paths: ${JSON.stringify(item?.readonly_paths || [])}`,
+        `Write paths: ${JSON.stringify(item?.write_paths || [])}`,
+        writeAllowed
+            ? 'If changes are needed, return model-authored patch_envelopes scoped to write paths.'
+            : 'This is read-only work. Do not mutate files and return an empty patch_envelopes array.',
+        'Include verification checks, rollback notes, blockers, findings, and changed_files.'
+    ].join('\n');
 }
 main().then(() => {
     process.exit(0);

package/dist/core/naruto/naruto-rebalance-policy.js

@@ -0,0 +1,48 @@
+import { chooseNarutoTaskOwner } from './naruto-allocation-policy.js';
+export function rebalanceNarutoReadyWork(input) {
+    const completed = new Set((input.completedTaskIds || []).map(String));
+    const reclaimed = new Set((input.reclaimedTaskIds || []).map(String));
+    const idle = input.workers.filter((worker) => worker.alive && ['idle', 'done', 'unknown'].includes(worker.state));
+    const activeWorkerIds = new Set(input.workers.filter((worker) => worker.alive).map((worker) => worker.id));
+    const activeWritePaths = new Set([...(input.activeWritePaths || []), ...(input.currentAssignments || []).flatMap((row) => row.write_paths || [])].map(normalizePath));
+    if (!idle.length)
+        return [];
+    const ready = input.tasks
+        .filter((task) => (task.status || 'pending') === 'pending')
+        .filter((task) => task.dependencies.every((dep) => completed.has(dep)))
+        .filter((task) => task.write_paths.every((file) => !activeWritePaths.has(normalizePath(file))))
+        .sort((left, right) => {
+        const reclaimedOrder = Number(!reclaimed.has(left.id)) - Number(!reclaimed.has(right.id));
+        return reclaimedOrder || left.id.localeCompare(right.id);
+    });
+    const decisions = [];
+    const assignments = [...(input.currentAssignments || [])];
+    for (const task of ready) {
+        const requestedOwner = task.owner ? String(task.owner) : '';
+        const ownerActive = requestedOwner && activeWorkerIds.has(requestedOwner);
+        const ownerIdle = ownerActive ? idle.some((worker) => worker.id === requestedOwner) : false;
+        if (requestedOwner && ownerActive && !ownerIdle)
+            continue;
+        const candidateWorkers = ownerIdle ? idle.filter((worker) => worker.id === requestedOwner) : idle;
+        const decision = chooseNarutoTaskOwner({ ...task, owner: null }, candidateWorkers, assignments);
+        decisions.push({
+            type: 'assign',
+            task_id: task.id,
+            worker_id: decision.owner,
+            reason: `${reclaimed.has(task.id) ? 'reclaimed ready work' : requestedOwner && !ownerActive ? `owner inactive:${requestedOwner}` : 'idle worker pickup'}; ${decision.reason}`
+        });
+        assignments.push({
+            task_id: task.id,
+            owner: decision.owner,
+            role: task.required_role,
+            paths: decision.hints.paths,
+            domains: decision.hints.domains,
+            write_paths: decision.hints.writePaths
+        });
+    }
+    return decisions;
+}
+function normalizePath(file) {
+    return String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '');
+}
+//# sourceMappingURL=naruto-rebalance-policy.js.map

package/dist/core/naruto/naruto-task-hints.js

@@ -0,0 +1,71 @@
+import { normalizeNarutoPath } from './naruto-work-item.js';
+const PATH_PATTERN = /(?:^|[\s("'`])((?:src|scripts|schemas|docs|test|tests|packages|crates|bin)\/[A-Za-z0-9._/-]+)/g;
+const DOMAIN_STOP_WORDS = new Set([
+    'the', 'and', 'for', 'with', 'into', 'from', 'task', 'work', 'worker', 'workers',
+    'implement', 'implementation', 'test', 'tests', 'check', 'gate', 'runtime',
+    'naruto', 'sks', 'src', 'core', 'scripts', 'docs', 'file', 'files'
+]);
+export function extractNarutoTaskHints(task) {
+    const record = task;
+    const writePaths = normalizePaths(readArray(record, 'write_paths', 'writePaths'));
+    const readPaths = normalizePaths([
+        ...readArray(record, 'readonly_paths', 'readPaths'),
+        ...readArray(record, 'target_paths')
+    ]);
+    const paths = normalizePaths([
+        ...readArray(record, 'target_paths'),
+        ...readArray(record, 'readonly_paths'),
+        ...readArray(record, 'write_paths'),
+        ...extractPathsFromText(`${readString(record, 'title')}\n${readString(record, 'description')}\n${readString(record, 'summary')}`)
+    ]);
+    const domains = [...new Set([
+            ...paths.flatMap(pathDomains),
+            ...extractDomainsFromText(`${readString(record, 'kind')} ${readString(record, 'title')} ${readString(record, 'description')}`)
+        ])].sort();
+    return {
+        paths,
+        domains,
+        role: readString(record, 'required_role') || readString(record, 'role') || null,
+        writePaths,
+        readPaths
+    };
+}
+export function pathPrefix(pathValue) {
+    const parts = normalizeNarutoPath(pathValue).split('/').filter(Boolean);
+    if (parts.length <= 1)
+        return parts[0] || '';
+    if (parts[0] === 'src' && parts.length >= 3)
+        return parts.slice(0, 3).join('/');
+    return parts.slice(0, 2).join('/');
+}
+function normalizePaths(paths) {
+    return [...new Set(paths.map((file) => normalizeNarutoPath(String(file || ''))).filter(Boolean))].sort();
+}
+function readArray(record, ...keys) {
+    return keys.flatMap((key) => Array.isArray(record[key]) ? record[key].map(String) : []);
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : value == null ? '' : String(value);
+}
+function extractPathsFromText(text) {
+    const out = [];
+    for (const match of String(text || '').matchAll(PATH_PATTERN)) {
+        if (match[1])
+            out.push(match[1]);
+    }
+    return out;
+}
+function extractDomainsFromText(text) {
+    return [...new Set(String(text || '').toLowerCase().match(/[a-z][a-z0-9_-]{2,}/g) || [])]
+        .filter((word) => !DOMAIN_STOP_WORDS.has(word))
+        .sort();
+}
+function pathDomains(pathValue) {
+    const normalized = normalizeNarutoPath(pathValue);
+    const parts = normalized.split('/').filter(Boolean);
+    const file = parts[parts.length - 1] || '';
+    const stem = file.replace(/\.[^.]+$/, '');
+    return [...new Set([pathPrefix(normalized), parts[0], parts[1], stem].filter((part) => Boolean(part)))];
+}
+//# sourceMappingURL=naruto-task-hints.js.map

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

@@ -42,6 +42,12 @@ export function buildNarutoWorkGraph(input = {}) {
         fallback_reason: writeCapable ? 'git_capability_not_evaluated' : 'readonly_or_write_disabled'
     };
     const workItems = [];
+    const assignmentById = new Map();
+    for (const row of input.allocationAssignments || []) {
+        const id = String(row.task_id || row.id || '');
+        if (id)
+            assignmentById.set(id, row);
+    }
     for (let index = 0; index < totalWorkItems; index += 1) {
         const id = `NW-${String(index + 1).padStart(6, '0')}`;
         const kind = kindCycle[index % kindCycle.length] || 'verification';
@@ -53,6 +59,8 @@ export function buildNarutoWorkGraph(input = {}) {
             ...writePaths.map((file) => ({ path: file, kind: 'write' })),
             ...readPaths.map((file) => ({ path: file, kind: 'read' }))
         ];
+        const assignment = assignmentById.get(id);
+        const allocationHints = assignment?.allocation_hints || assignment?.hints || null;
         workItems.push({
             id,
             kind,
@@ -73,6 +81,11 @@ export function buildNarutoWorkGraph(input = {}) {
                 requires_verification: kind !== 'research' && kind !== 'final_review_input_pack',
                 requires_gpt_final: writePaths.length > 0 || kind === 'final_review_input_pack'
             },
+            owner: assignment?.owner ?? null,
+            allocation_reason: assignment?.allocation_reason ?? null,
+            allocation_score: assignment?.allocation_score ?? null,
+            allocation_hints: allocationHints,
+            lane: assignment?.owner ?? null,
             ...(writePaths.length > 0 ? {
                 worktree: {
                     mode: worktreePolicy.mode,

package/dist/core/pipeline/finalize-pipeline-result.js

@@ -7,7 +7,8 @@ export async function finalizePipelineResult(input) {
     const root = path.resolve(input.mutationLedgerRoot || path.join(cwd, '.sneakoscope', 'tmp', 'pipeline-finalize', safeName(input.missionId)));
     const requirement = gptFinalRequiredForPipeline({
         localParticipated: input.localParticipated,
-        candidateResults: input.candidateResults
+        candidateResults: input.candidateResults,
+        candidatePatchEnvelopes: input.candidatePatchEnvelopes
     });
     let arbiter = null;
     let blockers = [];
@@ -36,6 +37,7 @@ export async function finalizePipelineResult(input) {
         route: input.route,
         mission_id: input.missionId,
         local_participated: requirement.local_participated,
+        worktree_participated: requirement.worktree_participated,
         gpt_final_required: requirement.gpt_final_required,
         gpt_final_arbiter: arbiter,
         final_status: blockers.length ? 'blocked' : 'accepted',

package/dist/core/pipeline/gpt-final-required.js

@@ -2,11 +2,31 @@ import { localCollaborationParticipated } from '../local-llm/local-collaboration
 export function gptFinalRequiredForPipeline(input) {
     const localParticipated = input.localParticipated === true
         || localCollaborationParticipated(Array.isArray(input.candidateResults) ? input.candidateResults : []);
+    const worktreeParticipated = worktreeCandidateParticipated(input.candidateResults)
+        || worktreeCandidateParticipated(input.candidatePatchEnvelopes);
     return {
         schema: 'sks.gpt-final-required.v1',
         local_participated: localParticipated,
-        gpt_final_required: localParticipated,
-        reason: localParticipated ? 'local_llm_outputs_are_drafts' : 'no_local_participation'
+        worktree_participated: worktreeParticipated,
+        gpt_final_required: localParticipated || worktreeParticipated,
+        reason: localParticipated
+            ? 'local_llm_outputs_are_drafts'
+            : worktreeParticipated
+                ? 'worktree_candidate_outputs_require_gpt_final'
+                : 'no_local_or_worktree_candidate_participation'
     };
 }
+function worktreeCandidateParticipated(values) {
+    return (Array.isArray(values) ? values : []).some((value) => {
+        if (!value || typeof value !== 'object')
+            return false;
+        if (value.source === 'git-worktree-diff')
+            return true;
+        if (value.git_worktree?.worktree_path || value.git_worktree?.checkpoint?.commit_hash)
+            return true;
+        if (value.git_worktree_diff || value.git_worktree_checkpoint)
+            return true;
+        return Array.isArray(value.patch_envelopes) && worktreeCandidateParticipated(value.patch_envelopes);
+    });
+}
 //# sourceMappingURL=gpt-final-required.js.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.10';
+export const PACKAGE_VERSION = '2.0.12';
 //# sourceMappingURL=version.js.map

package/dist/core/zellij/zellij-right-column-manager.js

@@ -13,6 +13,7 @@ export async function ensureRightColumn(input) {
         return writeRightColumnState(paths.statePath, {
             ...existing,
             updated_at: nowIso(),
+            slot_column_anchor_pane_id: existing.slot_column_anchor_pane_id || null,
             ui_mode: existing.ui_mode || uiMode
         });
     }
@@ -25,6 +26,7 @@ export async function ensureRightColumn(input) {
         status: 'creating',
         dashboard_pane_id: null,
         right_anchor_pane_id: null,
+        slot_column_anchor_pane_id: null,
         ui_mode: uiMode,
         visible_worker_panes: [],
         headless_workers: [],
@@ -38,6 +40,7 @@ export async function ensureRightColumn(input) {
             status: 'active',
             dashboard_pane_id: null,
             right_anchor_pane_id: null,
+            slot_column_anchor_pane_id: null,
             ui_mode: uiMode,
             blockers: []
         });
@@ -70,6 +73,7 @@ export async function ensureRightColumn(input) {
         status: blockers.length ? 'creating' : 'active',
         dashboard_pane_id: dashboard.pane_id ? String(dashboard.pane_id) : null,
         right_anchor_pane_id: dashboard.pane_id ? String(dashboard.pane_id) : null,
+        slot_column_anchor_pane_id: null,
         ui_mode: uiMode,
         blockers
     });
@@ -106,7 +110,7 @@ async function prepareWorkerInRightColumnUnlocked(input) {
         return { state: next, placement: 'headless', focusPaneId: null, yOrder: null };
     }
     const lastVisible = activeVisible[activeVisible.length - 1];
-    const focusPaneId = lastVisible?.pane_id || state.right_anchor_pane_id || state.dashboard_pane_id || null;
+    const focusPaneId = lastVisible?.pane_id || state.slot_column_anchor_pane_id || state.right_anchor_pane_id || state.dashboard_pane_id || null;
     const yOrder = Math.max(1, ...state.visible_worker_panes.map((pane) => Number(pane.y_order || 0) + 1));
     const next = await writeRightColumnState(paths.statePath, {
         ...state,
@@ -159,10 +163,48 @@ export async function recordWorkerPaneInRightColumn(input) {
         pane_id: input.record.pane_id,
         y_order: yOrder,
         direction_applied: input.record.direction_applied,
+        column_creation_direction_requested: input.record.column_creation_direction_requested || null,
+        column_creation_direction_applied: input.record.column_creation_direction_applied || null,
+        worker_direction_requested: input.record.worker_direction_requested,
+        worker_direction_applied: input.record.worker_direction_applied,
+        slot_column_anchor_pane_id: input.record.slot_column_anchor_pane_id || state.slot_column_anchor_pane_id || null,
         blockers: input.record.blockers
     });
     return next;
 }
+export async function recordSlotColumnAnchorInRightColumn(input) {
+    const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
+    const state = await readRightColumnState(input.root, input.missionId, input.projectRoot) || {
+        schema: ZELLIJ_RIGHT_COLUMN_STATE_SCHEMA,
+        generated_at: nowIso(),
+        updated_at: nowIso(),
+        mission_id: input.missionId,
+        session_name: input.sessionName,
+        status: 'active',
+        dashboard_pane_id: null,
+        right_anchor_pane_id: null,
+        slot_column_anchor_pane_id: null,
+        ui_mode: 'compact-slots',
+        visible_worker_panes: [],
+        headless_workers: [],
+        blockers: []
+    };
+    const paneId = input.paneId ? String(input.paneId) : null;
+    const next = await writeRightColumnState(paths.statePath, {
+        ...state,
+        updated_at: nowIso(),
+        status: 'active',
+        session_name: input.sessionName || state.session_name,
+        right_anchor_pane_id: paneId || state.right_anchor_pane_id,
+        slot_column_anchor_pane_id: paneId || state.slot_column_anchor_pane_id
+    });
+    await appendRightColumnEvent(paths.eventsPath, 'slot_column_anchor_created', next, {
+        pane_id: paneId,
+        column_creation_direction_requested: 'right',
+        column_creation_direction_applied: paneId ? 'right' : 'unknown'
+    });
+    return next;
+}
 export async function recordHeadlessWorkerInRightColumn(input) {
     return withRightColumnLock(input.root, input.missionId, async () => recordHeadlessWorkerInRightColumnUnlocked(input));
 }
@@ -177,6 +219,7 @@ async function recordHeadlessWorkerInRightColumnUnlocked(input) {
         status: 'absent',
         dashboard_pane_id: null,
         right_anchor_pane_id: null,
+        slot_column_anchor_pane_id: null,
         ui_mode: 'compact-slots',
         visible_worker_panes: [],
         headless_workers: [],
@@ -213,7 +256,7 @@ export async function closeWorkerInRightColumn(input) {
         ...state,
         updated_at: nowIso(),
         status: visibleStillActive.length || headlessStillActive.length ? 'active' : 'draining',
-        right_anchor_pane_id: visibleStillActive[visibleStillActive.length - 1]?.pane_id || state.dashboard_pane_id,
+        right_anchor_pane_id: visibleStillActive[visibleStillActive.length - 1]?.pane_id || state.slot_column_anchor_pane_id || state.dashboard_pane_id,
         visible_worker_panes: panes,
         headless_workers: headless
     });