0xray 3.5.4 → 4.0.0

package/dist/mcps/orchestrator/handlers/complexity-handler.js

@@ -5,8 +5,11 @@
  */
 import { frameworkLogger } from '../../../core/framework-logger.js';
 import { buildLeadDevPlan, buildSynthesisCheckpointPlan, isLeadDevModeActive, persistLeadDevPlan, } from '../../../nucleus/autonomy-kernel.js';
+import { formatConferQuorumReport, isConferEnabled, runConferQuorum, } from '../../../nucleus/confer.js';
 import { bindPlanToSession } from '../../../nucleus/lead-dev-plan-persistence.js';
 import { clearPendingDelegations } from '../../../nucleus/pending-delegations.js';
+import { isAutoProvisionWorktreeEnabled, provisionGitWorktree, } from '../../../nucleus/aside-worktree.js';
+import { buildUserAsidePlan, formatUserAsideSummary, isUserAsidesEnabled, loadUserAside, mergeUserAsideIntake, saveUserAside, setActiveAsideId, UserAsideValidationError, } from '../../../nucleus/user-aside.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { addObservations, extractComplexityObservations } from '../aside-context.js';
 function normalizeAnalyzeTasks(raw) {
@@ -61,13 +64,89 @@ export class ComplexityHandler {
                 .filter((t) => t.description?.trim())
                 .map((t) => ({ description: t.description, type: t.type }));
             const synthesisCheckpoint = args.synthesisCheckpoint === true;
-            const leadDevPlan = synthesisCheckpoint
-                ? buildSynthesisCheckpointPlan(args.synthesisDueReason ?? null)
-                : isLeadDevModeActive() && (primaryDescription || planTaskInputs.length > 0)
-                    ? buildLeadDevPlan(primaryDescription, taskTypes.length ? taskTypes : ['implement'], planTaskInputs, analysis.overallComplexity)
-                    : null;
-            let planPersisted = synthesisCheckpoint ? leadDevPlan !== null : !leadDevPlan;
-            if (leadDevPlan) {
+            const projectRoot = process.cwd();
+            const userAsideIntake = !synthesisCheckpoint &&
+                Boolean(args.userAsideId?.trim()) &&
+                isUserAsidesEnabled(projectRoot);
+            let userAsideReport = '';
+            let leadDevPlan = synthesisCheckpoint
+                ? buildSynthesisCheckpointPlan(args.synthesisDueReason ?? null, projectRoot)
+                : userAsideIntake
+                    ? null
+                    : isLeadDevModeActive() && (primaryDescription || planTaskInputs.length > 0)
+                        ? buildLeadDevPlan(primaryDescription, taskTypes.length ? taskTypes : ['implement'], planTaskInputs, analysis.overallComplexity, projectRoot)
+                        : null;
+            let planPersisted = synthesisCheckpoint
+                ? leadDevPlan !== null
+                : userAsideIntake
+                    ? false
+                    : !leadDevPlan;
+            if (userAsideIntake && args.userAsideId) {
+                try {
+                    const asideId = args.userAsideId.trim();
+                    const title = args.userAsideTitle?.trim() || asideId;
+                    const existing = loadUserAside(asideId, projectRoot);
+                    const userAside = existing
+                        ? mergeUserAsideIntake(existing, primaryDescription || existing.description, planTaskInputs, analysis.overallComplexity, projectRoot)
+                        : buildUserAsidePlan(asideId, title, primaryDescription || title, planTaskInputs, analysis.overallComplexity, projectRoot);
+                    if (!userAside) {
+                        planPersisted = false;
+                    }
+                    else {
+                        if (args.worktree)
+                            userAside.worktree = args.worktree;
+                        if (args.branch)
+                            userAside.branch = args.branch;
+                        if (args.sessionId)
+                            userAside.sessionId = args.sessionId;
+                        if (args.userAsideTitle)
+                            userAside.title = title;
+                        let worktreeProvisionNote = '';
+                        if (args.worktree?.trim() &&
+                            args.branch?.trim() &&
+                            isAutoProvisionWorktreeEnabled(projectRoot)) {
+                            const provision = provisionGitWorktree({
+                                projectRoot,
+                                worktree: args.worktree.trim(),
+                                branch: args.branch.trim(),
+                            });
+                            if (!provision.ok) {
+                                throw new UserAsideValidationError(`Worktree auto-provision failed: ${provision.message}`);
+                            }
+                            worktreeProvisionNote = provision.created
+                                ? `\n\n**Worktree provisioned:** \`${provision.path}\` (branch \`${args.branch.trim()}\`)`
+                                : `\n\n**Worktree ready:** \`${provision.path}\``;
+                        }
+                        const asidePath = saveUserAside(userAside, projectRoot);
+                        const activate = args.setActiveAside !== false;
+                        if (activate) {
+                            clearPendingDelegations(projectRoot);
+                            setActiveAsideId(asideId, projectRoot, args.sessionId ?? null);
+                        }
+                        planPersisted = true;
+                        userAsideReport = `\n\n## User aside\n\n${formatUserAsideSummary(userAside)}${worktreeProvisionNote}`;
+                        if (activate) {
+                            userAsideReport += `\n\n**Active aside:** \`${asideId}\` — spawns route to \`${asideId}.a.*\` todos.`;
+                        }
+                        await frameworkLogger.log('orchestrator.server', 'user-aside-persisted', 'info', {
+                            asidePath,
+                            asideId,
+                            todoCount: userAside.plan.phases.reduce((n, p) => n + p.todos.length, 0),
+                            activated: activate,
+                        });
+                    }
+                }
+                catch (err) {
+                    planPersisted = false;
+                    const message = err instanceof Error ? err.message : String(err);
+                    userAsideReport = `\n\n❌ User aside intake failed: ${message}`;
+                    await frameworkLogger.log('orchestrator.server', 'user-aside-persist-failed', 'warning', {
+                        error: message,
+                        validation: err instanceof UserAsideValidationError,
+                    });
+                }
+            }
+            else if (leadDevPlan) {
                 try {
                     const sessionId = args.sessionId ?? `analyze-${Date.now()}`;
                     if (!synthesisCheckpoint) {
@@ -90,13 +169,33 @@ export class ComplexityHandler {
                     await frameworkLogger.log('orchestrator.server', synthesisCheckpoint ? 'synthesis-plan-persist-failed' : 'lead-dev-plan-persist-failed', 'warning', { error: err instanceof Error ? err.message : String(err) });
                 }
             }
+            let conferReport = '';
+            if (synthesisCheckpoint &&
+                leadDevPlan &&
+                planPersisted &&
+                isConferEnabled() &&
+                args.sessionId) {
+                const conferOpts = {
+                    dueReason: args.synthesisDueReason ?? null,
+                    fixture: args.conferFixture === true,
+                };
+                if (args.collocatedText)
+                    conferOpts.collocatedText = args.collocatedText;
+                const conferResult = await runConferQuorum(process.cwd(), args.sessionId, conferOpts);
+                conferReport = `\n\n${formatConferQuorumReport(conferResult)}`;
+                await frameworkLogger.log('orchestrator.server', 'confer-quorum', conferResult.status === 'completed' ? 'info' : 'warning', {
+                    status: conferResult.status,
+                    agentCount: conferResult.agents.length,
+                    sessionId: args.sessionId,
+                });
+            }
             const ok = planPersisted;
             return {
                 ok,
                 content: [
                     {
                         type: 'text',
-                        text: this.formatComplexityResponse(analysis, recommendations, tasks.length, leadDevPlan, synthesisCheckpoint),
+                        text: this.formatComplexityResponse(analysis, recommendations, tasks.length, leadDevPlan, synthesisCheckpoint) + conferReport + userAsideReport,
                     },
                 ],
             };

package/dist/mcps/orchestrator/handlers/task-handler.d.ts

@@ -31,6 +31,12 @@ export declare class TaskHandler {
         sessionId?: string;
         executionMode?: string;
         timeout?: number;
+        confer?: boolean;
+        conferFixture?: boolean;
+        collocatedText?: string;
+        userAsideId?: string;
+        setActiveAside?: boolean;
+        clearActiveAside?: boolean;
     }, deps: TaskHandlerDeps): Promise<{
         content: Array<{
             type: string;

package/dist/mcps/orchestrator/handlers/task-handler.js

@@ -19,6 +19,81 @@ export class TaskHandler {
      * Handle orchestrate-task request
      */
     async handleOrchestrateTask(args, deps) {
+        if (args.clearActiveAside === true) {
+            const projectRoot = process.cwd();
+            const { clearActiveAside, getActiveAsideId } = await import('../../../nucleus/user-aside.js');
+            const prior = getActiveAsideId(projectRoot, args.sessionId ?? null);
+            clearActiveAside(projectRoot);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: prior
+                            ? `✅ Cleared active aside \`${prior}\` — spawns resume main lead-dev plan.`
+                            : 'ℹ️ No active aside was set.',
+                    },
+                ],
+            };
+        }
+        if (args.userAsideId?.trim()) {
+            const projectRoot = process.cwd();
+            const { setActiveAsideId, loadUserAside, formatUserAsideSummary, isUserAsidesEnabled, UserAsideValidationError, } = await import('../../../nucleus/user-aside.js');
+            const { clearPendingDelegations } = await import('../../../nucleus/pending-delegations.js');
+            if (!isUserAsidesEnabled(projectRoot)) {
+                return {
+                    content: [{ type: 'text', text: '❌ User asides disabled in features.json' }],
+                };
+            }
+            const asideId = args.userAsideId.trim();
+            const aside = loadUserAside(asideId, projectRoot);
+            if (!aside) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ User aside \`${asideId}\` not found — run analyze-complexity with userAsideId first.`,
+                        },
+                    ],
+                };
+            }
+            if (args.setActiveAside !== false) {
+                try {
+                    clearPendingDelegations(projectRoot);
+                    setActiveAsideId(asideId, projectRoot, args.sessionId ?? null);
+                }
+                catch (err) {
+                    const message = err instanceof UserAsideValidationError ? err.message : String(err);
+                    return { content: [{ type: 'text', text: `❌ ${message}` }] };
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Active aside: \`${asideId}\`\n\n${formatUserAsideSummary(aside)}`,
+                    },
+                ],
+            };
+        }
+        if (args.confer === true) {
+            const { runConferQuorum, formatConferQuorumReport, isConferEnabled } = await import('../../../nucleus/confer.js');
+            const sid = args.sessionId ?? `confer_${Date.now()}`;
+            if (!isConferEnabled()) {
+                return {
+                    content: [{ type: 'text', text: '❌ Confer disabled in features.json' }],
+                };
+            }
+            const conferOpts = {
+                dueReason: args.description,
+                fixture: args.conferFixture === true,
+            };
+            if (args.collocatedText)
+                conferOpts.collocatedText = args.collocatedText;
+            const result = await runConferQuorum(process.cwd(), sid, conferOpts);
+            return {
+                content: [{ type: 'text', text: formatConferQuorumReport(result) }],
+            };
+        }
         const { description, tasks = [], sessionId = `session_${Date.now()}`, executionMode = 'optimized', timeout = 300000 } = args;
         await frameworkLogger.log('orchestrator.server', 'orchestrate-task-start', 'info', { description, taskCount: tasks.length, sessionId, executionMode });
         const orchestrationResult = {

package/dist/mcps/orchestrator/server.js

@@ -99,13 +99,37 @@ export class OrchestratorServer {
                                     default: 'optimized',
                                 },
                                 timeout: { type: 'number', default: 300000 },
+                                confer: {
+                                    type: 'boolean',
+                                    description: 'Run mandatory 3-agent confer quorum (researcher, architect-tools, code-review) instead of task execution',
+                                },
+                                conferFixture: {
+                                    type: 'boolean',
+                                    description: 'Use fixture confer receipts (CI/verify)',
+                                },
+                                collocatedText: {
+                                    type: 'string',
+                                    description: 'Collocated synthesis context for confer prompts',
+                                },
+                                userAsideId: {
+                                    type: 'string',
+                                    description: 'Activate an existing user aside for spawn routing',
+                                },
+                                setActiveAside: {
+                                    type: 'boolean',
+                                    description: 'Set userAsideId as the active aside (default true)',
+                                },
+                                clearActiveAside: {
+                                    type: 'boolean',
+                                    description: 'Clear active aside — resume main lead-dev plan spawns',
+                                },
                             },
-                            required: ['description', 'tasks'],
+                            required: ['description'],
                         },
                     },
                     {
                         name: 'analyze-complexity',
-                        description: 'Analyze task complexity and recommend orchestration strategy. When lead_dev_mode is on (features.json), includes phased plan + todos + subagent routes. During synthesis checkpoint, returns collocated context and mandatory-consult realignment plan — pass sessionId from the active session.',
+                        description: 'Analyze task complexity and recommend orchestration strategy. When lead_dev_mode is on (features.json), includes phased plan + todos + subagent routes. Pass userAsideId to intake a parallel user aside ({asideId}.a.* namespaced todos, worktree-like). During synthesis checkpoint, returns collocated context and mandatory-consult realignment plan — pass sessionId from the active session.',
                         inputSchema: {
                             type: 'object',
                             properties: {
@@ -113,6 +137,26 @@ export class OrchestratorServer {
                                     type: 'string',
                                     description: 'Active session id (required to clear synthesis checkpoint; inferred from checkpoint state when omitted)',
                                 },
+                                userAsideId: {
+                                    type: 'string',
+                                    description: 'User aside id — persists .xray/state/asides/{id}.json with {asideId}.a.* todos (parallel track)',
+                                },
+                                userAsideTitle: {
+                                    type: 'string',
+                                    description: 'Display title for the user aside (defaults to userAsideId)',
+                                },
+                                worktree: {
+                                    type: 'string',
+                                    description: 'Optional worktree path for aside isolation',
+                                },
+                                branch: {
+                                    type: 'string',
+                                    description: 'Optional git branch for the aside',
+                                },
+                                setActiveAside: {
+                                    type: 'boolean',
+                                    description: 'Activate aside for spawn routing (default true when userAsideId set)',
+                                },
                                 tasks: {
                                     type: 'array',
                                     items: {
@@ -308,18 +352,23 @@ export class OrchestratorServer {
                                 ...complexityArgs,
                                 ...(sessionId ? { sessionId } : {}),
                                 ...(synthesisDue
-                                    ? { synthesisCheckpoint: true, synthesisDueReason: dueReason }
+                                    ? {
+                                        synthesisCheckpoint: true,
+                                        synthesisDueReason: dueReason,
+                                        collocatedText: collocated?.collatedText ?? null,
+                                        conferFixture: process.env.XRAY_CONFER_FIXTURE === '1',
+                                    }
                                     : {}),
                             }, aside.asideId);
                             let content = result.content;
                             if (synthesisDue && collocated?.collatedText) {
                                 content = appendSynthesisContextToResponse(content, collocated.collatedText);
                             }
-                            if (synthesisDue && result.ok) {
+                            if (synthesisDue && result.ok && !result.content[0]?.text?.includes('Confer quorum')) {
                                 content = content.map((block, index) => index === 0
                                     ? {
                                         ...block,
-                                        text: `${block.text}\n\n**Synthesis checkpoint remains active** until mandatory consult todos (s.1–s.3) are completed via Task spawns.`,
+                                        text: `${block.text}\n\n**Confer** runs automatically at synthesis checkpoint (researcher → architect-tools → code-review). Checkpoint clears when all consult todos complete.`,
                                     }
                                     : block);
                             }

package/dist/memory-routing/index.d.ts

@@ -1,6 +1,6 @@
 export type { MemoryRoutingProvider, MemoryRoutingContext, MemoryInheritedContext, MemoryAgentCapability, MemoryOrchestrationTask, MemoryThinDispatchResult, MemoryRoutingConfig, OrchestratorFeedbackEntry, } from './types.js';
 export { getMemoryRoutingProvider, getMemoryRoutingProviderSync, getMemoryRoutingConfig, resetMemoryRoutingProvider, initializeMemoryRouting, } from './provider-registry.js';
 export { NullMemoryRoutingProvider, createMemoryRoutingProvider } from './null-provider.js';
-export { loadMemoryRoutingProvider } from './provider-loader.js';
+export { loadMemoryRoutingProvider, isLeftoverMemoryRoutingOff, isExplicitMemoryRoutingOptOut, resolveLeftoverEnabledConfig, } from './provider-loader.js';
 export { validateMemoryRoutingConfig } from './validate-config.js';
 export type { MemoryRoutingValidation } from './validate-config.js';

package/dist/memory-routing/index.js

@@ -1,4 +1,4 @@
 export { getMemoryRoutingProvider, getMemoryRoutingProviderSync, getMemoryRoutingConfig, resetMemoryRoutingProvider, initializeMemoryRouting, } from './provider-registry.js';
 export { NullMemoryRoutingProvider, createMemoryRoutingProvider } from './null-provider.js';
-export { loadMemoryRoutingProvider } from './provider-loader.js';
+export { loadMemoryRoutingProvider, isLeftoverMemoryRoutingOff, isExplicitMemoryRoutingOptOut, resolveLeftoverEnabledConfig, } from './provider-loader.js';
 export { validateMemoryRoutingConfig } from './validate-config.js';

package/dist/memory-routing/provider-loader.d.ts

@@ -1,2 +1,6 @@
 import type { MemoryRoutingConfig, MemoryRoutingProvider } from './types.js';
+export declare function isExplicitMemoryRoutingOptOut(config: MemoryRoutingConfig): boolean;
+/** Leftover shipped default: enabled false + provider null. Not an explicit opt-out. */
+export declare function isLeftoverMemoryRoutingOff(config: MemoryRoutingConfig): boolean;
+export declare function resolveLeftoverEnabledConfig(config: MemoryRoutingConfig, cwd: string): MemoryRoutingConfig | null;
 export declare function loadMemoryRoutingProvider(config: MemoryRoutingConfig, cwd?: string): Promise<MemoryRoutingProvider>;

package/dist/memory-routing/provider-loader.js

@@ -1,10 +1,27 @@
 import { existsSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
+import { resolve, dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { frameworkLogger } from '../core/framework-logger.js';
 import { createMemoryRoutingProvider as createNullProvider } from './null-provider.js';
 import { validateMemoryRoutingConfig } from './validate-config.js';
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveUnavailableReason(provider) {
+    const statusProvider = provider;
+    if (typeof statusProvider.getAvailabilityStatus !== 'function') {
+        return null;
+    }
+    try {
+        return statusProvider.getAvailabilityStatus().reason ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 const REPERTOIRE_CANDIDATE_PATHS = [
+    'node_modules/@0xray/repertoire/dist/provider/memory-routing-provider.js',
+    'vendor/@0xray/repertoire/dist/provider/memory-routing-provider.js',
     '../repertoire/dist/provider/memory-routing-provider.js',
     '../../repertoire/dist/provider/memory-routing-provider.js',
     '../../../repertoire/dist/provider/memory-routing-provider.js',
@@ -35,15 +52,55 @@ function defaultPathForProvider(provider, cwd) {
         if (existsSync(abs))
             return abs;
     }
+    const nm = join(cwd, 'node_modules', '@0xray', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js');
+    return existsSync(nm) ? nm : null;
+}
+export function isExplicitMemoryRoutingOptOut(config) {
+    return config.enabled === false && config.provider === 'repertoire';
+}
+/** Leftover shipped default: enabled false + provider null. Not an explicit opt-out. */
+export function isLeftoverMemoryRoutingOff(config) {
+    if (config.enabled === true)
+        return false;
+    if (isExplicitMemoryRoutingOptOut(config))
+        return false;
+    return config.provider === 'null' || !config.provider;
+}
+function leftoverRepertoireModulePath(cwd) {
+    const nm = join(cwd, 'node_modules', '@0xray', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js');
+    if (existsSync(nm))
+        return nm;
+    const vendor = join(cwd, 'vendor', '@0xray', 'repertoire', 'dist', 'provider', 'memory-routing-provider.js');
+    if (existsSync(vendor))
+        return vendor;
+    const sibling = resolve(cwd, '../repertoire/dist/provider/memory-routing-provider.js');
+    if (existsSync(sibling))
+        return sibling;
     return null;
 }
+export function resolveLeftoverEnabledConfig(config, cwd) {
+    if (!isLeftoverMemoryRoutingOff(config))
+        return null;
+    const modulePath = resolveModulePath(config.module_path, cwd) ?? leftoverRepertoireModulePath(cwd);
+    if (!modulePath)
+        return null;
+    const enabled = {
+        enabled: true,
+        provider: 'repertoire',
+        module_path: modulePath,
+    };
+    if (config.config)
+        enabled.config = config.config;
+    return enabled;
+}
 export async function loadMemoryRoutingProvider(config, cwd = process.cwd()) {
     const validation = validateMemoryRoutingConfig(config);
     if (!validation.valid) {
         await frameworkLogger.log('memory-routing', 'config-invalid', 'error', { errors: validation.errors, provider: config.provider });
         return createNullProvider();
     }
-    const effective = validation.normalized;
+    const leftover = resolveLeftoverEnabledConfig(validation.normalized, cwd);
+    const effective = leftover ?? validation.normalized;
     if (!effective.enabled || effective.provider === 'null') {
         return createNullProvider();
     }
@@ -68,13 +125,26 @@ export async function loadMemoryRoutingProvider(config, cwd = process.cwd()) {
         if (!provider?.id || typeof provider.isAvailable !== 'function') {
             throw new Error(`Invalid memory routing provider from ${modulePath}`);
         }
+        const availabilityReason = resolveUnavailableReason(provider);
         if (!provider.isAvailable()) {
             await frameworkLogger.log('memory-routing', 'provider-unavailable', 'error', {
                 providerId: provider.id,
                 modulePath,
-                message: `Provider "${provider.id}" loaded but isAvailable() returned false. Falling back to null provider.`,
+                unavailableReason: availabilityReason,
+                message: `Provider "${provider.id}" loaded but isAvailable() returned false (${availabilityReason ?? 'unknown'}). Falling back to null provider.`,
             });
-            return createNullProvider();
+            if (availabilityReason === 'empty_registry') {
+                await sleep(100);
+                if (provider.isAvailable()) {
+                    await frameworkLogger.log('memory-routing', 'provider-retry-ok', 'info', { providerId: provider.id, modulePath });
+                }
+                else {
+                    return createNullProvider();
+                }
+            }
+            else {
+                return createNullProvider();
+            }
         }
         await frameworkLogger.log('memory-routing', 'provider-loaded', 'info', { providerId: provider.id, name: provider.name, modulePath });
         return provider;

package/dist/memory-routing/provider-registry.js

@@ -1,6 +1,6 @@
 import { featuresConfigLoader } from '../core/features-config.js';
 import { NullMemoryRoutingProvider } from './null-provider.js';
-import { loadMemoryRoutingProvider } from './provider-loader.js';
+import { loadMemoryRoutingProvider, resolveLeftoverEnabledConfig } from './provider-loader.js';
 import { validateMemoryRoutingConfig } from './validate-config.js';
 let cachedProvider = null;
 let loadPromise = null;
@@ -8,7 +8,8 @@ const nullProviderSingleton = new NullMemoryRoutingProvider();
 export function getMemoryRoutingConfig() {
     const raw = featuresConfigLoader.loadConfig().memory_routing;
     const validation = validateMemoryRoutingConfig(raw ?? { enabled: false, provider: 'null' });
-    return validation.normalized;
+    return (resolveLeftoverEnabledConfig(validation.normalized, process.cwd()) ??
+        validation.normalized);
 }
 export async function getMemoryRoutingProvider(forceReload = false) {
     if (!forceReload && cachedProvider)

package/dist/nucleus/aside-worktree.d.ts

@@ -0,0 +1,41 @@
+/**
+ * User-aside worktree path resolution, spawn cwd validation, optional git provision.
+ */
+/** Minimal spawn tool input for cwd extraction (avoids circular import with delegation-gate). */
+export interface SpawnCwdToolInput {
+    cwd?: string;
+    working_directory?: string;
+    workingDirectory?: string;
+    isolation?: string;
+    isolation_mode?: string;
+    worktree_path?: string;
+    worktreePath?: string;
+    worktree?: string;
+    [key: string]: unknown;
+}
+export interface AsideWorktreeCwdResult {
+    valid: boolean;
+    gate?: 'aside-worktree-cwd-missing' | 'aside-worktree-cwd-mismatch';
+    reason?: string;
+    hint?: Record<string, unknown>;
+}
+export interface WorktreeProvisionResult {
+    ok: boolean;
+    path: string;
+    created: boolean;
+    message: string;
+}
+export declare function normalizeWorktreePath(worktree: string, projectRoot: string): string;
+export declare function isAutoProvisionWorktreeEnabled(projectRoot?: string): boolean;
+/** Extract spawn cwd from host Task / spawn_subagent tool input. */
+export declare function extractSpawnCwd(toolInput: SpawnCwdToolInput, projectRoot: string): string | null;
+export declare function validateAsideWorktreeCwd(worktree: string | undefined, toolInput: SpawnCwdToolInput, projectRoot: string): AsideWorktreeCwdResult;
+/**
+ * Guarded `git worktree add` when auto_provision_worktree is enabled.
+ * Creates branch with -b when it does not exist locally.
+ */
+export declare function provisionGitWorktree(opts: {
+    projectRoot: string;
+    worktree: string;
+    branch: string;
+}): WorktreeProvisionResult;