taskchef 8.7.0 → 9.0.0

package/scripts/e2e-benchmark.js

@@ -1,206 +0,0 @@
-#!/usr/bin/env node
-
-import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { normalizeCodexThreadId } from "../src/delegation.js";
-
-const BENCHMARK_NAME = "taskchef-executor-self-link-e2e";
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-const RESULT_FILENAME = new RegExp(
-  `^\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}\\.\\d{3}Z-${BENCHMARK_NAME}\\.json$`,
-);
-
-function managedResultFilename(name) {
-  if (!RESULT_FILENAME.test(name)) return false;
-  const timestampPart = name.slice(0, -`-${BENCHMARK_NAME}.json`.length);
-  const iso = `${timestampPart.slice(0, 13)}:${timestampPart.slice(14, 16)}:${timestampPart.slice(17)}`;
-  try {
-    timestamp(iso, "result filename timestamp");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function object(value, name) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${name} must be an object`);
-  return value;
-}
-
-function exact(value, keys, name) {
-  object(value, name);
-  const expected = new Set(keys);
-  const unexpected = Object.keys(value).find((key) => !expected.has(key));
-  if (unexpected) throw new Error(`${name} has unsupported field: ${unexpected}`);
-  const missing = keys.find((key) => !(key in value));
-  if (missing) throw new Error(`${name} is missing field: ${missing}`);
-  return value;
-}
-
-function string(value, name) {
-  if (typeof value !== "string" || value.trim() === "") throw new Error(`${name} must be a non-empty string`);
-  return value;
-}
-
-function timestamp(value, name) {
-  string(value, name);
-  const milliseconds = Date.parse(value);
-  if (
-    !/^\d{4}-\d{2}-\d{2}T.*Z$/.test(value)
-    || Number.isNaN(milliseconds)
-    || new Date(milliseconds).toISOString() !== value
-  ) {
-    throw new Error(`${name} must be a canonical four-digit-year UTC timestamp`);
-  }
-  return milliseconds;
-}
-
-function uuid(value, name) {
-  string(value, name);
-  if (!UUID_PATTERN.test(value)) throw new Error(`${name} must be a lowercase full UUID`);
-  return value;
-}
-
-function codexUuid(value, name) {
-  return normalizeCodexThreadId(value, name);
-}
-
-export function normalizeBenchmarkResult(input, { requireDerived = false } = {}) {
-  const value = structuredClone(object(input, "benchmark result"));
-  if (!("summary" in value) && !requireDerived) value.summary = undefined;
-  exact(value, [
-    "schemaVersion", "benchmark", "taskchefVersion", "runId", "startedAt", "completedAt",
-    "workload", "task", "turns", "events", "validation", "summary",
-  ], "benchmark result");
-  if (value.schemaVersion !== 2) throw new Error("schemaVersion must be 2");
-  if (value.benchmark !== BENCHMARK_NAME) throw new Error(`benchmark must be ${BENCHMARK_NAME}`);
-  string(value.taskchefVersion, "taskchefVersion");
-  string(value.runId, "runId");
-  const started = timestamp(value.startedAt, "startedAt");
-  const completed = timestamp(value.completedAt, "completedAt");
-  if (completed < started) throw new Error("completedAt must not precede startedAt");
-
-  exact(value.workload, ["project", "title", "prompt"], "workload");
-  for (const key of ["project", "title", "prompt"]) string(value.workload[key], `workload.${key}`);
-  if (/<!--\s*taskchef_id=/i.test(value.workload.prompt)) throw new Error("workload.prompt must not contain a TaskChef marker");
-
-  exact(value.task, ["taskId", "threadId", "clientThreadId", "recorded", "linked"], "task");
-  uuid(value.task.taskId, "task.taskId");
-  value.task.threadId = codexUuid(value.task.threadId, "task.threadId");
-  if (value.task.clientThreadId !== null) {
-    string(value.task.clientThreadId, "task.clientThreadId");
-    if (!value.task.clientThreadId.startsWith("local:")) throw new Error("task.clientThreadId must be provisional");
-  }
-  for (const key of ["recorded", "linked"]) {
-    if (typeof value.task[key] !== "boolean") throw new Error(`task.${key} must be boolean`);
-  }
-  if (!value.task.recorded || !value.task.linked) throw new Error("benchmark task must be recorded and self-linked");
-
-  exact(value.turns, ["needsInput", "completion"], "turns");
-  value.turns.needsInput = codexUuid(value.turns.needsInput, "turns.needsInput");
-  value.turns.completion = codexUuid(value.turns.completion, "turns.completion");
-  if (value.turns.completion <= value.turns.needsInput) {
-    throw new Error("follow-up completion must use a newer turn ID");
-  }
-
-  const eventNames = ["preparedAt", "recordedAt", "createdAt", "linkedAt", "needsInputAt", "followedUpAt", "completedAt"];
-  exact(value.events, eventNames, "events");
-  let previous = started;
-  for (const name of eventNames) {
-    const current = timestamp(value.events[name], `events.${name}`);
-    if (current < previous || current > completed) throw new Error("events must be ordered within the benchmark interval");
-    previous = current;
-  }
-  if (Date.parse(value.events.recordedAt) > Date.parse(value.events.createdAt)) throw new Error("record must precede native creation");
-
-  const validationNames = [
-    "exactMarkerCorrelated", "noDispatcherPostCreateReads", "childIdentityVerified",
-    "parentIdentityRejected", "linkRetryVerified", "needsInputVerified",
-    "followUpTurnFresh", "dashboardDeepLinkVerified", "outputVerified",
-  ];
-  exact(value.validation, validationNames, "validation");
-  for (const name of validationNames) {
-    if (typeof value.validation[name] !== "boolean") throw new Error(`validation.${name} must be boolean`);
-    if (!value.validation[name]) throw new Error(`validation.${name} must be true for a successful benchmark`);
-  }
-
-  const summary = {
-    totalWallMs: completed - started,
-    provisionalPath: value.task.clientThreadId !== null,
-    linked: value.task.linked,
-    freshFollowUp: value.turns.needsInput !== value.turns.completion,
-  };
-  if (requireDerived && value.summary === undefined) throw new Error("summary is required in a saved result");
-  if (value.summary !== undefined) {
-    exact(value.summary, Object.keys(summary), "summary");
-    if (Object.entries(summary).some(([key, expected]) => value.summary[key] !== expected)) {
-      throw new Error("summary does not match the derived benchmark summary");
-    }
-  }
-  value.summary = summary;
-  return value;
-}
-
-function timestampFilename(iso) {
-  return iso.replaceAll(":", "-");
-}
-
-export async function writeBenchmarkResult(input, outputDirectory) {
-  const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
-  const result = normalizeBenchmarkResult({ ...input, taskchefVersion: packageJson.version });
-  await mkdir(outputDirectory, { recursive: true });
-  const outputPath = path.join(outputDirectory, `${timestampFilename(result.startedAt)}-${BENCHMARK_NAME}.json`);
-  await writeFile(outputPath, `${JSON.stringify(result, null, 2)}\n`, { flag: "wx" });
-  return { outputPath, result };
-}
-
-export async function cleanBenchmarkResults(outputDirectory) {
-  const entries = await readdir(outputDirectory, { withFileTypes: true }).catch((error) => {
-    if (error.code === "ENOENT") return [];
-    throw error;
-  });
-  const removed = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || !managedResultFilename(entry.name)) continue;
-    await unlink(path.join(outputDirectory, entry.name));
-    removed.push(entry.name);
-  }
-  return removed.sort();
-}
-
-async function readJsonStdin() {
-  if (process.stdin.isTTY) throw new Error("write requires non-interactive JSON on stdin");
-  let input = "";
-  process.stdin.setEncoding("utf8");
-  for await (const chunk of process.stdin) input += chunk;
-  if (input.trim() === "") throw new Error("expected benchmark JSON on stdin");
-  return JSON.parse(input);
-}
-
-async function main(args) {
-  const command = args[0];
-  const target = path.resolve(args[1] ?? "reports/e2e-benchmarks");
-  if (command === "write") {
-    const { outputPath, result } = await writeBenchmarkResult(await readJsonStdin(), target);
-    process.stdout.write(`${JSON.stringify({ outputPath, summary: result.summary })}\n`);
-    return;
-  }
-  if (command === "validate") {
-    const result = normalizeBenchmarkResult(JSON.parse(await readFile(target, "utf8")), { requireDerived: true });
-    process.stdout.write(`${JSON.stringify({ inputPath: target, summary: result.summary })}\n`);
-    return;
-  }
-  if (command === "clean") {
-    process.stdout.write(`${JSON.stringify({ outputDirectory: target, removed: await cleanBenchmarkResults(target) })}\n`);
-    return;
-  }
-  throw new Error("usage: e2e-benchmark.js <write|validate|clean> [path]");
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  main(process.argv.slice(2)).catch((error) => {
-    process.stderr.write(`${error.message}\n`);
-    process.exitCode = 1;
-  });
-}

package/scripts/roles/resolve_roles.py

@@ -1,293 +0,0 @@
-#!/usr/bin/env python3
-"""Read native Codex agent preferences without applying their instruction layers.
-
-Requires Python 3.11+. Standalone, standard library only. TaskChef packages an
-identical copy; neither installation imports the other at runtime.
-"""
-import argparse
-import json
-import os
-from pathlib import Path
-import re
-import sys
-import tomllib
-
-ROLES = ('orchestrator', 'planner', 'implementer', 'reviewer')
-EFFORTS = ('none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra')
-
-
-def read_layer(directory):
-    found = {}
-    problems = []
-    try:
-        with os.scandir(directory) as entries:
-            files = sorted(Path(entry.path) for entry in entries if entry.name.endswith('.toml'))
-        for file in files:
-            try:
-                if file.stat().st_size > 65536:
-                    raise ValueError('profile exceeds 64 KiB')
-                with file.open('rb') as stream:
-                    data = tomllib.load(stream)
-                name = data.get('name')
-                if name not in ROLES:
-                    if file.stem in ROLES:
-                        raise ValueError('name must match the role filename')
-                    continue
-                errors = []
-                for field in ('description', 'developer_instructions'):
-                    if not isinstance(data.get(field), str) or not data[field].strip():
-                        errors.append(f'{field} must be a nonempty string')
-                model = data.get('model')
-                effort = data.get('model_reasoning_effort')
-                entry = {'source': str(file), 'model': model, 'effort': effort, 'problems': errors}
-                if name in found:
-                    entry['problems'].append('duplicate role name in the same directory')
-                found[name] = entry
-            except (OSError, ValueError) as error:
-                # Do not expose TOML lines, which can contain unrelated private data.
-                message = f'{file}: unreadable or malformed agent TOML ({type(error).__name__})'
-                problems.append(message)
-                if file.stem in ROLES:
-                    found[file.stem] = {'source': str(file), 'model': None, 'effort': None, 'problems': [message]}
-    except FileNotFoundError:
-        return found, problems
-    except OSError:
-        message = f'{directory}: cannot read agent directory'
-        problems.append(message)
-        found = {role: {'source': str(directory), 'model': None, 'effort': None, 'problems': [message]} for role in ROLES}
-    return found, problems
-
-
-def resolve(codex_home=None, explicit_model=None, explicit_effort=None):
-    home = Path(codex_home or os.environ.get('CODEX_HOME') or Path.home() / '.codex').expanduser().resolve()
-    personal, problems = read_layer(home / 'agents')
-    catalog = None
-    catalog_source = str(home / 'models_cache.json')
-    try:
-        cache = json.loads(Path(catalog_source).read_text())
-        if not isinstance(cache, dict) or not isinstance(cache.get('models'), list):
-            raise ValueError('invalid catalog')
-        for model in cache['models']:
-            if not isinstance(model, dict) or not isinstance(model.get('slug'), str):
-                raise ValueError('invalid model entry')
-            levels = model.get('supported_reasoning_levels')
-            if not isinstance(levels, list) or any(not isinstance(level, dict) or not isinstance(level.get('effort'), str) for level in levels):
-                raise ValueError('invalid effort catalog')
-        catalog = {model['slug']: model for model in cache['models']}
-    except FileNotFoundError:
-        pass
-    except (OSError, ValueError, KeyError, TypeError):
-        problems.append('Local Codex model catalog is unreadable or malformed; validate availability with the current native tool.')
-    results = []
-    for role in ROLES:
-        entry = personal.get(role)
-        source = entry['source'] if entry else None
-        model = entry['model'] if entry else None
-        effort = entry['effort'] if entry else None
-        errors = list(entry['problems']) if entry else []
-        if explicit_model is not None:
-            model, effort = explicit_model, explicit_effort
-            effective_source = 'explicit user model choice'
-            errors = []
-        else:
-            effective_source = source
-            if explicit_effort is not None:
-                effort = explicit_effort
-        if model is not None and (not isinstance(model, str) or not model.strip() or len(model) > 256):
-            errors.append('model must be a nonempty string of at most 256 characters')
-        if effort is not None and effort not in EFFORTS:
-            errors.append('reasoning effort is unsupported')
-        status = 'invalid' if errors else 'configured' if (model is not None or effort is not None) else 'missing'
-        availability = 'not checked; native tool must validate before dispatch'
-        if model and not errors and catalog is not None:
-            if model not in catalog:
-                errors.append('model absent from local Codex catalog; confirm against the current native tool before dispatch')
-                status = 'unavailable'
-            else:
-                supported = [v.get('effort') for v in catalog[model].get('supported_reasoning_levels', []) if isinstance(v, dict)]
-                if effort and effort not in supported:
-                    errors.append('effort absent from local model catalog; confirm against the current native tool')
-                    status = 'unavailable'
-                availability = 'present in cached catalog; current native tool is authoritative'
-        overrides = {}
-        if status == 'configured':
-            if model is not None:
-                overrides['model'] = model
-            if effort is not None:
-                overrides['thinking'] = effort
-        results.append({'role': role, 'source': source, 'effectiveSource': effective_source,
-                        'model': model, 'effort': effort, 'status': status,
-                        'availability': availability, 'problems': errors,
-                        'taskOverrides': overrides,
-                        'subagentOverrides': {('reasoning_effort' if k == 'thinking' else k): v for k, v in overrides.items()},
-                        'fallback': 'native new-task default' if role == 'orchestrator' else 'inherit parent settings'})
-    model_options = [] if catalog is None else [
-        {'value': slug, 'label': entry.get('display_name') or slug,
-         'efforts': [level['effort'] for level in entry['supported_reasoning_levels']]}
-        for slug, entry in catalog.items() if entry.get('visibility') != 'hide'
-    ]
-    return {'roles': results, 'problems': problems, 'catalogSource': catalog_source if catalog is not None else None,
-            'modelOptions': model_options,
-            'precedence': 'explicit user model (and its explicit effort) > personal role > native defaults; explicit effort alone overrides role effort',
-            'scope': 'Model and effort only; agent instructions, tools, permissions, and other TOML keys are not applied by this adapter.'}
-
-
-def setup(role, model, effort, codex_home=None):
-    home = Path(codex_home or os.environ.get('CODEX_HOME') or Path.home() / '.codex').expanduser().resolve()
-    existing, problems = read_layer(home / 'agents')
-    if role in existing or problems:
-        return {'created': False, 'role': role, 'problems': problems or ['existing role preserved'], 'source': existing.get(role, {}).get('source')}
-    if not model.strip() or len(model) > 256 or effort not in EFFORTS:
-        raise ValueError('invalid model or effort')
-    directory = home / 'agents'
-    directory.mkdir(parents=True, exist_ok=True)
-    target = directory / f'{role}.toml'
-    data = {'name': role, 'description': f'{role.capitalize()} model preferences',
-            'developer_instructions': f'Perform the assigned {role} work within the user\'s requested scope.',
-            'model': model, 'model_reasoning_effort': effort}
-    try:
-        with target.open('x') as stream:
-            stream.write(''.join(f'{key} = {json.dumps(value)}\n' for key, value in data.items()))
-    except FileExistsError:
-        return {'created': False, 'role': role, 'source': str(target), 'problems': ['existing file preserved']}
-    return {'created': True, 'role': role, 'source': str(target), 'model': model, 'effort': effort}
-
-
-def multiline_state(line, state=None):
-    """Track TOML multiline strings without interpreting their contents as keys."""
-    index = 0
-    while index < len(line):
-        if state:
-            closing = line.find(state, index)
-            while closing >= 0 and state == '"""':
-                escapes = 0
-                cursor = closing - 1
-                while cursor >= 0 and line[cursor] == '\\':
-                    escapes += 1
-                    cursor -= 1
-                if escapes % 2 == 0:
-                    break
-                closing = line.find(state, closing + 3)
-            if closing < 0:
-                return state
-            state = None
-            index = closing + 3
-            continue
-        if line[index] == '#':
-            return None
-        if line.startswith('"""', index) or line.startswith("'''", index):
-            state = line[index:index + 3]
-            index += 3
-            continue
-        if line[index] in ('"', "'"):
-            quote = line[index]
-            index += 1
-            while index < len(line):
-                if line[index] == quote and (quote == "'" or index == 0 or line[index - 1] != '\\'):
-                    index += 1
-                    break
-                if quote == '"' and line[index] == '\\':
-                    index += 2
-                else:
-                    index += 1
-            continue
-        index += 1
-    return state
-
-
-def replace_top_level_preferences(content, model, effort):
-    replacements = {
-        'model': json.dumps(model),
-        'model_reasoning_effort': json.dumps(effort),
-    }
-    assignment = re.compile(
-        r'^(?P<prefix>\s*(?P<key>model|model_reasoning_effort|["\']model["\']|["\']model_reasoning_effort["\'])\s*=\s*).*$'
-    )
-    lines = content.splitlines(keepends=True)
-    state = None
-    boundary = len(lines)
-    found = set()
-    for index, line in enumerate(lines):
-        if state is None and re.match(r'^\s*\[', line):
-            boundary = index
-            break
-        if state is None:
-            body = line.rstrip('\r\n')
-            ending = line[len(body):]
-            match = assignment.match(body)
-            if match:
-                key = match.group('key').strip('"\'')
-                lines[index] = f"{match.group('prefix')}{replacements[key]}{ending}"
-                found.add(key)
-        state = multiline_state(line, state)
-    missing = [f'{key} = {value}\n' for key, value in replacements.items() if key not in found]
-    if missing:
-        prefix = '' if boundary == 0 or lines[boundary - 1].endswith(('\n', '\r')) else '\n'
-        lines[boundary:boundary] = [prefix + ''.join(missing)]
-    candidate = ''.join(lines)
-    expected = tomllib.loads(content)
-    expected['model'] = model
-    expected['model_reasoning_effort'] = effort
-    if tomllib.loads(candidate) != expected:
-        raise ValueError('agent TOML could not be updated without changing unrelated settings')
-    return candidate
-
-
-def update(role, model, effort, codex_home=None):
-    home = Path(codex_home or os.environ.get('CODEX_HOME') or Path.home() / '.codex').expanduser().resolve()
-    resolved = resolve(codex_home=str(home))
-    options = {entry['value']: entry for entry in resolved['modelOptions']}
-    if model not in options or effort not in options[model]['efforts']:
-        raise ValueError('model or reasoning effort is unavailable')
-    existing, layer_problems = read_layer(home / 'agents')
-    role_entry = existing.get(role)
-    if layer_problems or (role_entry and role_entry['problems']):
-        raise ValueError('existing role configuration must be fixed before editing')
-    if role_entry is None:
-        return setup(role, model, effort, str(home))
-    target = Path(role_entry['source'])
-    agents = (home / 'agents').resolve()
-    if target.is_symlink() or target.resolve().parent != agents:
-        raise ValueError('role source is outside the personal agent directory')
-    content = replace_top_level_preferences(target.read_text(), model, effort)
-    temporary = target.with_name(f'.{target.name}.{os.getpid()}.tmp')
-    try:
-        temporary.write_text(content)
-        os.chmod(temporary, target.stat().st_mode & 0o777)
-        os.replace(temporary, target)
-    finally:
-        try:
-            temporary.unlink()
-        except FileNotFoundError:
-            pass
-    return {'updated': True, 'role': role, 'source': str(target), 'model': model, 'effort': effort}
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument('--codex-home')
-    parser.add_argument('--role', choices=ROLES)
-    parser.add_argument('--model')
-    parser.add_argument('--effort')
-    parser.add_argument('--setup', action='store_true')
-    parser.add_argument('--update', action='store_true')
-    args = parser.parse_args()
-    if args.setup and args.update:
-        parser.error('--setup and --update are mutually exclusive')
-    if args.setup:
-        if not (args.role and args.model and args.effort):
-            parser.error('--setup requires --role, --model, and --effort')
-        result = setup(args.role, args.model, args.effort, args.codex_home)
-    elif args.update:
-        if not (args.role and args.model and args.effort):
-            parser.error('--update requires --role, --model, and --effort')
-        result = update(args.role, args.model, args.effort, args.codex_home)
-    else:
-        result = resolve(args.codex_home, args.model, args.effort)
-        if args.role:
-            result['roles'] = [r for r in result['roles'] if r['role'] == args.role]
-    print(json.dumps(result, indent=2))
-
-
-if __name__ == '__main__':
-    main()

package/skills/taskchef-bootstrap/SKILL.md

@@ -1,96 +0,0 @@
----
-name: taskchef-bootstrap
-description: "Initialize or repair the TaskChef dispatcher workspace and manage its local Codex project index. Use for setup, doctor, import, or reindex requests; not dispatch or executor reporting."
----
-
-# TaskChef Bootstrap
-
-Initialize or refresh the per-user TaskChef dispatcher workspace at
-`~/.agents/taskchef`.
-
-Resolve this skill directory with `realpath`. The TaskChef plugin root is two
-parents above the skill directory. Invoke `<plugin-root>/bin/taskchef.js` for
-all deterministic workspace operations.
-
-## Boundaries
-
-- Keep implementation, tests, and reports in the TaskChef source repository.
-- Create and manage only AGENTS.md, taskchef.json, tasks.jsonl,
-  config-audit.jsonl, and TaskChef's private backups and maintenance artifacts
-  in a dispatcher workspace. Preserve unrelated user-owned paths.
-- Do not dispatch tasks or report on executor threads during bootstrap unless
-  the user separately requests those actions.
-- Never create hooks, schedules, polling, daemons, login items, or system
-  services. The managed dispatcher instructions own best-effort dashboard
-  startup and final-link guidance; bootstrap only refreshes that managed block.
-  TaskChef executors self-link through the installed MCP server.
-
-## Initialize and repair
-
-1. Run `workspace path --json` and use its returned canonical path for native
-   project comparisons. The CLI resolves `--workspace`, then
-   an absolute (or `~/`-prefixed) `TASKCHEF_WORKSPACE`, then
-   `~/.agents/taskchef`; do not infer a workspace
-   from the current project.
-2. List native Codex projects once. If an exact canonical-path local project
-   already exists, run `workspace init --json`. Otherwise run
-   `workspace init --register-codex --json`, then list native projects once more
-   and require one exact canonical-path local project. `--register-codex`
-   invokes the supported `codex app <path>` command through a validated Codex
-   CLI discovered from the current desktop environment; never invoke
-   `codex add` or hard-code an application bundle path.
-3. After registration is verified, pass the final native schema-2 snapshot to
-   `reconcile_projects` once. Preserve its diagnostics; one unavailable or
-   ineligible project does not invalidate eligible additions.
-4. `workspace init` takes no stdin, creates an empty
-   configuration when missing, creates the one-entry-per-task JSONL log, and
-   refreshes managed instructions. The installed plugin provides all four
-   TaskChef skills outside the dispatcher workspace.
-5. Run `doctor --json` after setup or when the user asks to diagnose the
-   workspace. Doctor is read-only. Rerun `workspace init --json` to repair the
-   managed scaffold.
-6. Report the actions or failed checks. A successful initialization with failed
-   Codex opening remains initialized but not verified as a saved local project.
-   End without dispatching unless the user
-   separately requested work.
-
-## Project index operations
-
-For adding, importing, removing, listing, or reindexing projects, read
-[project index](references/project-index.md). Preserve exact canonical local
-Codex project identity and existing curated entries; opening a folder is not
-proof of registration. Completion requires verifying the intended index entry
-and the complete project set. Any operation that removes a project entry
-requires the user's explicit permission for the exact removed names; removing a
-repository URL from an entry does not authorize removing the entry.
-Removal records a reconciliation exclusion. Use `include_project` only after an
-explicit request to include that exact native project again, then reconcile a
-fresh native snapshot. An identity/path move remains diagnostic until the old
-exact entry is removed through its preview-bound workflow, its exclusion is
-explicitly cleared, and reconciliation validates the new target.
-
-## Optional model roles
-
-Offer planner, implementer, and reviewer profiles during setup. Model and effort
-preferences belong in user configuration, never defaults hard-coded in skills.
-If the user provides values, configure them without asking again. Otherwise
-explain the optional profiles and retain native defaults until values are chosen.
-
-Run `python3 <plugin-root>/scripts/roles/resolve_roles.py` to preview personal
-roles. Python 3.11+ is required for this optional helper. Create each requested
-missing profile with:
-
-```sh
-python3 <plugin-root>/scripts/roles/resolve_roles.py --setup --role <role> --model <requested-model> --effort <requested-effort>
-```
-
-This authorized role setup may create `$CODEX_HOME/agents/<role>.toml` (default
-`~/.codex/agents/`) outside the dispatcher workspace. Existing definitions,
-including custom filenames, are preserved. Report conflicts and diagnostics;
-never overwrite a custom role. Re-run the preview and check model/effort against
-the available native interface. Missing roles are optional: TaskChef omits
-new-task overrides; reviewers inherit parent settings. Native new-task defaults
-are not guaranteed dispatcher inheritance. Read the delegate's
-[role resolution](../taskchef-delegate/references/model-roles.md) for precedence
-and adapter limits. Open the dashboard's `/#settings` preview to show the
-configured sources, requested effective settings, fallback, and problems.

package/skills/taskchef-bootstrap/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "TaskChef Bootstrap"
-  short_description: "Bootstrap the per-user TaskChef workspace"
-  default_prompt: "Use $taskchef-bootstrap to initialize or refresh my per-user TaskChef dispatcher workspace."