Licensed under Apache-2.0. See NOTICE for redistribution notice details.
A creative workflow kit for Codex and ChatGPT Work: briefs, references, direction, image and video prompts, QA and delivery. Static graphic design is integrated into the existing skills, not installed as a separate asset.
Installation guidance is English. After verified installation, the workflow adapts to your language without treating this page's copied prompts as your language preference.
Your account and workspace must expose native Skills and @skill-creator.
Opening Work alone is not enough. Access depends on product availability and
workspace permissions; see Skills in ChatGPT.
If those capabilities are missing, use an eligible workspace or the Codex route below.
Open ChatGPT, switch the top selector from Chat to Work, and paste:
Use @skill-creator to create and save selected native ChatGPT Skills from this public repository:
https://github.com/FrameCoreWorks/framecore-works-codex-chatgpt-workflow-kit
First read and follow CHATGPT_INSTALL.md, config/chatgpt-skills.json and
config/chatgpt-skill-sources.json. Follow the English onboarding, confirm my Workflow Profile and
the exact skill list, and let me choose guided or batch installation. Obtain the required
conversational approval before creation.
Read every declared source file for the selected skills. Use the actual native creation and save
workflow, keep each skill separate, and check the saved result. Do not create duplicates, substitute
a Codex installation, clone a workspace or run shell commands. If Skills, @skill-creator, source
access or saving are unavailable, stop and report the concrete blocker. A draft or approval is not a
completed installation.
Keep installation in English. Only after verified installation, resolve my working language from my
own conversation or explicit preference, not this copied English prompt. Explain how to use and
extend the installed skills. Do not activate providers, upload files or publish anything.
This creates the selected native skills, without a local clone or Codex agent files. Full setup rules: CHATGPT_INSTALL.md. For profiles, source files, approval modes and troubleshooting, see Native ChatGPT Skills.
Use the built-in $skill-installer route to install the selected Skills into
your personal Codex Skills directory. Open Codex and paste:
Use $skill-installer to install selected FrameCore workflow Skills from this public repository:
https://github.com/FrameCoreWorks/framecore-works-codex-chatgpt-workflow-kit
First read CODEX_INSTALL.md. Confirm that this is Codex and that the built-in $skill-installer is
available. Keep installation guidance in English; do not infer my language from this copied prompt.
Resolve the latest main commit once. Read the guide, profiles and source inventory at that same
full commit. Recommend the smallest useful core, creative or full profile, show the exact Skill
list and destination, and obtain my approval before installation.
Use the native $skill-installer helper with --repo, the pinned --ref and only the approved
.agents/skills/<skill-name> paths. Install into $CODEX_HOME/skills, using the host's actual default.
Do not clone this repository into my project, run the project-local installer or install agent
TOMLs, AGENTS files, project config or a .framecore manifest.
Preflight every selected destination and verify every declared source file and SHA-256 before
writes. If a Skill already exists in the destination or another active scope, stop and follow
CODEX_UPDATE.md for that existing installation; do not overwrite it or create a duplicate.
Do not treat a multi-Skill installation as atomic. After any failure, inspect actual saved state
and report which Skills succeeded, failed or were not attempted before proposing recovery.
After installation, verify the complete saved inventory and bytes against the pinned source.
Record source identity and verification outside the Skill bundles. Only then resolve my working
language from my explicit preference or own conversation, excluding copied setup prompts; use a
reliably exposed locale only as a fallback, otherwise English. Explain the installed Skills and
give one useful starter prompt. Tell me they will be available on my next turn without claiming
that host activation was observed. Do not use providers, upload files or publish anything.
This installs the existing Skills, including integrated static-design knowledge. It does not create a project checkout or install a separate Static Graphic Design Creator asset. Full source, collision and readback rules: CODEX_INSTALL.md. If the installer or required access is unavailable, nothing was installed.
The optional advanced project-local installer additionally provides agent TOMLs, project config, instructions and a managed manifest. Choose it explicitly: project install, CLI Quickstart or Codex-assisted project install. GitHub Desktop is an optional visual cloning tool for that advanced route, not a requirement for native Skill installation.
Updates start with a read-only comparison and need approval before replacement. They preserve the existing installation and personal changes; they do not run in the background or create a second copy.
In Work with the existing native skills and @skill-creator available, paste:
Use @skill-creator to update my existing native ChatGPT Skills from:
https://github.com/FrameCoreWorks/framecore-works-codex-chatgpt-workflow-kit
First read CHATGPT_UPDATE.md. Identify the actual installed Skills, their source evidence and the
active host's supported editing and readback capabilities. Update the existing entries only; do not
create duplicate Skills or substitute a Codex installation.
Resolve the latest main commit once and pin all configuration, source inventory and source reads to
that same full commit. Compare the previous verified source when available, the new source and the
actual installed content. Report the target commit, changed/new/removed/already-current files,
personal edits, conflicts and verification limits. Do not infer exact upstream identity from names
or package version.
Prepare a complete conflict-safe proposal read-only. Preserve personal additions and unrelated
behavior. If there is no upstream change, report already_up_to_date or
local_customizations_preserved without saving. Otherwise show the exact Delta and obtain my approval
before editing any saved Skill.
After approval, use the actual native editing workflow for the same entries, then read back and
verify the intended content and preserved resources. Approval, a local draft or an already visible
library entry alone is not proof of a successful update. If a save response fails or is lost,
inspect actual saved state before considering another attempt; do not retry or roll back blindly.
Explain results in my resolved working language because the Skills are already installed, but keep
public source descriptions in English. Do not use shell commands, global installs, providers,
uploads, publishing or background updates.
The existing native entries are updated through the supported save workflow. Source comparison, recovery and readback rules: CHATGPT_UPDATE.md.
For existing native Codex Skills, use $skill-creator, not a fresh
$skill-installer run. Paste:
Use $skill-creator to update my existing installed FrameCore Skills from:
https://github.com/FrameCoreWorks/framecore-works-codex-chatgpt-workflow-kit
First read CODEX_UPDATE.md. Confirm the actual Codex host, exact existing Skill paths and source
evidence. This updates the same Skills; do not use $skill-installer as an updater, create duplicates
or clone a repository into my project. If a project .framecore/manifest.json owns these files, use
docs/codex-project-update.md for that scope instead. Do not silently move between installation
scopes.
Resolve the latest main commit once and pin the guide, configuration, inventory and all source
reads to that same full commit. Verify source paths and SHA-256 hashes. Compare the actual installed
content, the previous verified source when available, and the new source. If the old baseline is
unknown, say so; do not invent a three-way comparison or infer provenance from a Skill name.
Prepare the complete proposal read-only: changed, new, retired and unchanged files, exact conflict
diffs, personal additions, preserved behavior, validation and rollback. An upstream update does not
authorize installing extra Skills. Preserve existing Skill identity and local extensions. If there
is no update to apply, report already_up_to_date or local_customizations_preserved without writing.
Show Delta and verification, then wait for my approval before any saved change. Unresolved conflicts
block the update. After approval, recheck the source and installed bytes for drift, preserve a
recoverable snapshot outside the bundles and apply only the approved changes to the same paths.
Read back the complete result, verify hashes and preserved resources, run relevant bundled checks
when available, and repeat comparison against the same source without another save. Record actual
source identity, local deviations and saved digests outside the bundles only after verification.
If saving or verification fails, inspect actual state before recovery; do not blindly retry or
roll back over later user edits.
Use my resolved working language because the Skills are already installed. Keep public sources in
English. Do not upload, publish, activate providers or change unrelated configuration.
Read-only comparison, approval and saved-file verification:
CODEX_UPDATE.md. For an advanced project-local installation
owned by .framecore/manifest.json, use the separate
project update guide.
Use this when you want an existing skill to fit your work better: add examples, formats, references, decision rules or QA checks. This is a personal extension, not an upstream update or a new skill. The assistant first asks what should change, prepares a proposal and waits for approval.
Replace <skill-name> with one installed skill, such as
image-prompt-architect. The kit has no automatic extension-folder convention;
supporting resources must be explicitly loaded by that skill. Personal overrides
remain visible during later updates. See Skill customization.
In a Work conversation with the existing skill and @skill-creator available, paste:
Use @skill-creator to help me extend my existing native FrameCore Skill: <skill-name>.
This is a guided personal extension, not a fresh install, upstream update or public repository edit.
Identify the existing native entry and use this host's actual edit/save workflow. Do not create a
duplicate or substitute a Codex filesystem installation. Resolve my working language from my
explicit preference and own conversation because this Skill is already installed.
Inspect the current Skill and its accessible resources. Ask what I want to add, change or
specialize, then request only the necessary examples and constraints. Prepare a read-only Change
Proposal: objective, exact scope, preserved behavior, expected benefit, conflicts, acceptance test,
rollback and stop condition. Wait for my approval before any saved change.
Preserve a recoverable baseline using a supported private mechanism. Apply only the approved
extension, keep the upstream source identity unchanged and preserve unrelated behavior. A supporting
file must be explicitly loaded by the Skill; do not invent automatic extension-folder support.
Verify the actual saved identity, complete intended content and preserved resources. A draft,
approval or existing library entry is not proof of persistence. If saving fails or the response is
lost, inspect actual saved state first. Do not blindly retry, roll back, force-push or switch save
services. Report preparation, persistence and verification separately, and stop if reliable readback
is unavailable. Do not publish personal files, upload assets, activate providers or run background
updates.
Open Codex with the existing Skill and $skill-creator available, then paste:
Use $skill-creator to help me extend my existing installed FrameCore Skill: <skill-name>.
This is a guided personal extension, not a fresh install, upstream update or public repository edit.
Locate the exact existing Skill and confirm its installation scope. Do not create a duplicate or
clone another repository into my project. Resolve my working language from my explicit preference
and own conversation because this Skill is already installed.
First inspect its instructions and resources. Check personal and project scopes for collisions;
inspect managed-file status only if a project manifest owns this Skill. Ask what I want to add,
change or specialize, using only the examples and constraints needed to define the change.
Before writing, propose the objective, exact files, preserved behavior, expected benefit, conflicts,
acceptance test, rollback and stop condition. Prepare exact changes read-only and wait for my
approval.
Prefer supporting resources inside the existing Skill when appropriate. Do not assume that
local/SKILL_EXTENSIONS.md or any other filename is automatically loaded: include the smallest
explicit loading instruction in the approved change when needed. Explain that editing kit-managed
files is a personal override that can block a later upstream update.
After approval, preserve a recoverable snapshot, apply only the agreed changes, validate the
complete resulting Skill and read back the saved bytes. Preserve unrelated files and the upstream
source identity. Do not change manifest hashes merely to hide local drift. Report what changed, how
to test it and how to undo it. Do not publish, upload, use providers or modify global configuration.
This skill kit provides native Codex Skills through $skill-installer and the same public skill contracts as repository-source native ChatGPT Skills. It does not install paid providers or API-key tooling. It gives the active surface a structured way to move work from request intake to brief, references, direction, prompts, QA, and delivery notes. An optional advanced Codex project-local install additionally supplies agents, manifests, and long-session recovery tooling.
This is a human-in-the-loop workflow kit, not an autonomous agent system. It helps a user and the active Codex or ChatGPT surface structure work through skills, temporary or local role responsibilities, gates, artifacts, and QA.
The user remains responsible for the goal, facts, source materials, permissions, approvals, and final decisions. Role-agent templates and skills guide model behavior; they are not background workers, a task queue, or a guarantee that every workflow step was followed. Local tooling can enforce install, manifest, path, schema, fixture, and package-safety rules, but it cannot certify the quality of a model response or silently complete work.
The kit does not start hidden background work, autonomously execute a workflow, or claim that an unverified step has been completed. Where evidence matters, the workflow records artifacts, QA results, caveats, and the user-visible stop decision.
At a glance, the repo includes:
- 20 Codex role-agent templates for routing, creative planning, prompting, QA, delivery, and execution documentation.
- 35 portable workflow skills for brief building, research evidence, copy and voice, ecommerce strategy, screenplay development, creative video production, captions, OpenCut and Remotion production, safe tool-routing and cost planning, image and video prompting, storyboard work, Humanizer, integrated HyperFrames planning, Hipson-style packets, QA, delivery, onboarding, and workflow self-improvement. Every skill includes native UI metadata and a public source mapping for the Codex
$skill-installeror ChatGPT@skill-creatorroute. - Optional advanced project-local install and onboarding with doctor/preflight, dry-run, manifest tracking, update, repair, and uninstall.
- Workflow contracts for gates, handoffs, artifact schemas, examples, Loop Protocol, and provider-neutral safety boundaries.
For the full inventory, see Included Agents And Skills. For iterative QA and repair discipline, see Loop Protocol. For ready-to-use copy, voice, captions, and editorial delivery rules, see Human Voice And Copy Delivery. For the staged adoption plan, see Loop Protocol Integration Plan.
| Area | Included examples |
|---|---|
| Core routing | intent-confirmation, workflow-orchestrator, instruction-packet-factory, pipeline-core |
| Creative planning | brief-architect, reference-curator, ecommerce-campaign-strategy-director, screenplay-story-architect, campaign and storytelling skills |
| Video production | creative-video-producer, producer-ai-task-builder, caption-studio, opencut-video-studio, remotion-video-production, storyboard and HyperFrames skills |
| Prompt production | image-prompting, video-prompting, image-prompt-architect, video-prompt-architect |
| QA and delivery | qa-iteration, asset-manifest, delivery-documentation, output critique and delivery skills |
| Long-session support | Context/, Memory Cache/, Project State templates, semantic-memory helpers |
| Specialized workflow knowledge | Humanizer, ecommerce strategy, screenplay development, captions, OpenCut planning, Remotion production, HyperFrames, lightweight Hipson Adapter, storyboard board planning |
The kit provides the workflow spine: roles, gates, handoffs, artifact expectations, examples, safety boundaries, onboarding, and update/repair lifecycle. Users can layer deeper domain-specific prompting or execution tools on top, but those provider/tool integrations are intentionally not bundled here.
Static graphic design is integrated into the existing direction, copy, reference, image-prompting, QA and asset-manifest skills. It adds objective-first concepts, composition and typography guidance, an optional 200-code poster catalog, one-pass prompt construction and bounded repair/DTP handoffs. There is no separate Static Graphic Design Creator skill or installation; the inventory remains 35 skills.
On both supported surfaces, ordinary natural-language requests can route to eligible installed skills. Routing should stay proportional to the task:
- a request for one image prompt, video prompt, brief, storyboard, caption plan, or review uses the smallest relevant specialist route;
- an end-to-end campaign, production pack, or other genuinely multi-stage task can activate orchestration, dependent skills, gates, handoffs, and QA;
- the
workflow-orchestratorskill explicitly asks for route selection and visible state; - the
pipeline-coreskill explicitly asks for governed multi-stage routing, while still skipping irrelevant stages.
ChatGPT ultimately controls native implicit invocation, so exact natural-language routing can vary with the active product surface. In ChatGPT Work, use @workflow-orchestrator or @pipeline-core when route predictability matters. In Codex, use $workflow-orchestrator or $pipeline-core. Onboarding, the optional Hipson Adapter, and workflow self-improvement remain explicit-only and do not start from unrelated requests.
Installed ChatGPT Skills remain editable. In Work, use @skill-creator and ask it to change a named skill, add examples, refine its output format, or strengthen its QA checks. To create a new personal skill, start with:
Use @skill-creator to help me create a skill.
| Surface | What works | Notes |
|---|---|---|
Codex with built-in $skill-installer |
Selected personal Skills in $CODEX_HOME/skills |
Default Codex route. Does not create project agents, config or a managed manifest. |
| OpenAI Codex CLI with custom-agent support | Full project-local install, AGENTS.md, skills, rendered .codex/agents/*.toml, guided install, doctor, update, repair, uninstall |
Optional advanced mode for explicitly requested project agents and lifecycle tooling. |
| OpenAI Codex or ChatGPT environments that read project instructions but do not expose custom-agent spawning | AGENTS.md, installed skills, workflow docs, examples, artifact contracts |
.codex/agents/*.toml may be inert, but the workflow contracts remain useful. |
| Native ChatGPT Skills | Repository-source skill creation, UI metadata, guided onboarding, reusable workflow instructions, and temporary task roles | Requires native Skills, ChatGPT Work, @skill-creator, public GitHub source access, conversational approval in batch or guided mode, and a real creation result for each selected skill. |
| Other AGENTS-aware coding agents or editors | AGENTS.md, docs, examples, and reusable skill files when read manually |
Custom-agent .toml files are Codex-specific and may not be consumed. |
| Chat-only environments without native Skills | Documentation and manual guidance only | Use a ChatGPT account with native Skills, or use a local terminal or shell-capable Codex workspace. |
| Path | Included in this repo | What it does |
|---|---|---|
| Prompt-only workflow | Yes | Produces briefs, reference packs, direction, prompt packs, QA criteria, and delivery notes. |
| Built-in Codex/ChatGPT image generation for generated static raster graphics | Policy only | Default route when available and explicitly requested by the user; visible text is generated in one pass. |
| External paid media-provider execution | No | Users may add their own tools outside this public kit. |
| Full Hipson | No | The included Hipson Adapter is lightweight; full Hipson remains separate and optional. |
- It does not install paid media providers, API keys, provider CLIs, or external execution tools.
- It does not upload files, publish outputs, or send work to cloud folders by default.
- It does not make the ChatGPT Chat surface behave like a shell-capable Codex workspace or the native Skill creation surface. Use ChatGPT Work with
@skill-creatorfor native Skills. - It does not automatically generate PDFs, videos, images, or final delivery packages without a clear user request and an available execution surface.
- It does not install full Hipson; it includes only a lightweight adapter for bounded packets and handoffs.
- It does not overwrite user-owned files unless the user intentionally approves a force path.
Skills are workflow contracts, not personality presets. A skill defines when a workflow role should act, what input it needs, what artifact it must produce, which QA gate applies, and where the handoff goes next.
Onboarding does not rewrite that workflow logic. In native Codex Skills it produces a visible Workflow Profile; the optional project-local CLI can render that profile into workspace configuration. In ChatGPT it creates a visible neutral Workflow Profile, temporary role rules, safety boundaries, and a reusable starter prompt.
- First installation: read Getting Started In 5 Minutes.
- Installing native Codex Skills: use CODEX_INSTALL.md and
$skill-installer. - Choosing the advanced project-local CLI: read Quickstart.
- Adding project agents and configuration: read Codex-Assisted Project Install.
- Using native ChatGPT Skills instead of Codex: read Native ChatGPT Skills.
- Already installed and ready to work: read Using The Kit.
- Already installed and want the newest repo changes: use Codex update.
- Installation failed or produced an unexpected result: read Troubleshooting.
- Need quick answers first: read FAQ.
- Want to see exactly what is included: read Included Agents And Skills.
- Want to see how workflow pieces fit together: read Workflow Map.
- Sending test results or a bug report: use Tester Feedback Guide.
- Checking supported environments and install modes: read Compatibility.
- Want command behavior and safety boundaries: read CLI Reference.
- Want the mental model first: read Architecture.
- Running long Codex sessions or handoffs: read Memory Cache and Context Folder.
- Using local semantic lookup: read Semantic Memory.
- Need the local OpenAI API boundary: read OpenAI API Policy.
- Want to understand current limits and planned direction: read Roadmap.
- Want the future plugin or bundle direction: read Bundle Readiness.
- Preparing for a stable public release: read v1.0 Readiness.
- Verifying behavior in a real Codex workspace before broad promotion: read Live Codex E2E Check.
- Recording reviewed live Codex evidence: use E2E Results and E2E Result Template.
- Checking what provider-neutral allows and forbids: read Provider-Neutral Boundary.
- Want to compare workflow paths: open Examples Index.
- Using the kit with a team: read Team Configuration.
- Want to see a complete workflow specimen: open End-To-End Creative Workflow Example.
- Maintaining example routes: use each example's checked
workflow.json. - Adding or maintaining public examples: read Example Authoring.
- Maintaining artifact contracts: read Artifact Schemas.
- Preparing a release or repo maintenance change: read Release Guide.
- Migrating reusable workflow logic from another setup: read Migration Guide.
- Configuring GitHub protections for this public repo: read Repository Settings.
- Already installing: use the short install flow below.
The default native Codex route installs only approved Skill bundles in
$CODEX_HOME/skills/<skill-name>. ChatGPT creates the equivalent selected native
entries. Neither route installs project agents, configuration or a manifest.
The optional advanced project-local installer can additionally provide:
- Role-based Codex agent templates with local display-name customization.
- Workflow skills for intake, references, research, direction, copy, prompts, QA, delivery, and retrospectives.
- Humanizer for natural copy polish and voice consistency.
- HyperFrames workflow knowledge for coded video planning, scene structure, animation guidance, caption planning, render QA, and delivery manifests.
- Hipson Adapter for research maps, internet mapping packets, bounded instruction packets, review packets, and execution packets.
- Project State templates for durable run-state, context recovery, blockers, touched files, and next-action handoff.
- Memory Cache templates and local tools for long-session recovery, context-budget checks, semantic lookup, and report-only self-improvement queues.
The advanced project-local install writes only exact FrameCore-managed files:
.agents/skills/<framecore-skill>/....codex/agents/<role-id>.tomlAGENTS.mdwhen no projectAGENTS.mdexists yetAGENTS.framecore.mdwhen the project already has its ownAGENTS.md.framecore/manifest.json
The repo also includes validation and privacy audit scripts for checking this kit before installation or contribution. The audit rejects private names, excluded provider remnants, local machine paths, emails, secret files, secret-like values, private cloud links/IDs, symlinks, and AppleDouble metadata files.
This kit contains reusable workflow assets: role-based agents, skills, templates, onboarding, validation, and project-local configuration.
Public documentation, source instructions, metadata and installation prompts are English. Only after verified installation does the host resolve the user's working language: explicit preference, then user-authored conversation, then reliably exposed locale, otherwise English. Copied English setup prompts do not set the user's language. Do not infer hidden account settings. Deliverable-language requests and exact artwork copy remain separate. The CLI stays English; the installed conversational workflow adapts without translating public source files.
The commands below are for the optional advanced project-local installer only. For the default native Skills route, use CODEX_INSTALL.md.
For guided project setup, run:
npm run install:guided -- --target /path/to/your/projectFor a non-interactive default setup in an existing target workspace:
npm run install:guided -- --target /path/to/your/project --defaults --yesThe guided installer refuses missing targets, runs repository checks, runs doctor/preflight, runs onboarding, performs a post-onboarding dry-run, asks before the final install unless --yes is used, and installs project-local only.
To verify the golden install path in a temporary target without touching a real project:
npm run smoke:installThe smoke check runs default onboarding, guided project-local install, expected file checks, manifest hash checks, doctor/preflight, and uninstall preview.
Manual fallback:
-
Clone or download this repo.
-
Check the repository:
npm run check
-
Run preflight:
npm run doctor -- --target /path/to/your/project
-
Review the preflight result. The installer refuses to overwrite user-owned files by default.
-
Run onboarding:
node scripts/onboard.mjs --target /path/to/your/project
-
Run dry run after onboarding so rendered agents use the final local config:
npm run install:dry-run -- --target /path/to/your/project
-
Install project-local:
node scripts/install.mjs --mode project-local --target /path/to/your/project
If your project already has AGENTS.md, the installer writes AGENTS.framecore.md instead. Use --force only when you intentionally want FrameCore to overwrite a conflicting user-owned file.
Global install is available only for advanced users. This CLI home-workspace
mode is separate from the default native $CODEX_HOME/skills route. It writes to the current user's home workspace, so preview it first:
npm run doctor -- --mode global
node scripts/install.mjs --mode dry-run --target "$HOME"Apply global install only when that is intentional:
node scripts/install.mjs --mode global --confirm-globalUse --mode dry-run first for every install target.
These CLI commands manage advanced project installations only. They are not updaters for native personal Skills; those use CODEX_UPDATE.md. Refresh and verify the CLI source via project update before using the commands below.
Update requires an existing .framecore/manifest.json, upgrades the current FrameCore-managed set, and refuses user-owned conflicts. It also refuses locally edited managed files when their manifest hashes changed; rerun with --force only when you intentionally want to overwrite those local edits after creating backups:
node scripts/install.mjs --mode update --target /path/to/your/projectRepair also requires a manifest, but rewrites only paths already recorded in that manifest. It does not add new managed paths, and it applies the same local-edit hash protection as update:
node scripts/install.mjs --mode repair --target /path/to/your/projectBefore update or repair overwrites changed managed files or rewrites a changed manifest, it creates numbered .bak backups such as AGENTS.md.bak or .framecore/manifest.json.bak. If a managed file is already byte-identical to the kit output, update leaves it untouched and does not create a backup.
Uninstall previews removals by default:
node scripts/install.mjs --mode uninstall --target /path/to/your/projectApply uninstall with:
node scripts/install.mjs --mode uninstall --target /path/to/your/project --yesUninstall removes only exact files recorded in the manifest. It refuses directory removals and unsafe paths.
Backup files are not added to the manifest and are preserved for manual review or removal.
Native Skill onboarding keeps a visible Workflow Profile and requires no project config. Save personal preferences only through an approved host-supported route. The following CLI onboarding and generated files apply to the advanced project mode.
Project onboarding collects:
- response tone
- local display names for role-based agents
- output folder
- QA strictness
- optional recurring workflow self-improvement review
- optional full Hipson expansion
Agent source files in this repo use neutral role IDs only. User-specific display names are generated locally and should not be committed.
framecore.config.json is validated before rendering or installation. Invalid config values stop installation before managed files are written. Teams can add an optional framecore.config.shared.json for reviewed shared defaults; local framecore.config.json still takes precedence.
Generated static raster graphics should use the built-in Codex/ChatGPT image generation capability powered by GPT Image 2 by default when available. This includes posters, social graphics, banners, infographics, thumbnails, ecommerce graphics, storyboard boards, and similar bitmap visuals.
Static raster graphics with visible text must use the same built-in path in one pass, with all visible text included directly in the generated image.
This is a native chat-window generation path, not an external provider integration, API key requirement, CLI, or paid media-provider workflow. The workflow must not replace requested graphic generation with Python-generated artwork, SVG, HTML/canvas, Sharp/composited PNG, or other coded artwork unless the user explicitly asks for a coded, vector, template, or editable source artifact. It also must not generate a text-free background first and add typography later with overlays, compositing, design tools, or manual editing unless the user explicitly asks for a coded or vector artifact.
This repo includes only the lightweight Hipson Adapter. It works inside this architecture as a packet factory for:
- research maps
- internet mapping packets
- bounded instruction packets
- review packets
- execution packets
The full Hipson system is an optional external extension maintained separately at:
https://github.com/Hipson47/Hipson.git
Onboarding explains the current adapter scope and lets the user record whether they intend to connect the full Hipson system later. It does not clone, install, or activate full Hipson during kit setup.
The workflow-self-improvement skill is explicit-only. It creates retrospective notes and change proposals. It does not run as a hidden daemon, edit instructions automatically, upload files, run external tools, or perform destructive operations.
Onboarding can optionally create a report-only 24-hour review recipe. The default is disabled.
The local self:audit and self:improve:local commands write proposal queues into a valid Memory Cache/. They do not patch source files.
For long-running projects, create an operational folder with separate Context/ and Memory Cache/ folders:
npm run memory:init -- --target /path/to/operational-folder --create-target
npm run memory:validate -- --target /path/to/operational-folderContext/ is for user-supplied briefs, references, attachments, and source data. Memory Cache/ is for durable recovery state, checkpoint IDs, safe resume notes, decision logs, source maps, and artifact indexes. The tools do not repopulate Context/ from Memory Cache/.
Local semantic memory works without API access:
npm run semantic:index -- --target /path/to/operational-folder
npm run semantic:query -- --target /path/to/operational-folder --query "recovery prompt"OpenAI API paths require the exact activation phrase openai api active. Without that phrase, API-gated commands stop before any API-capable work.
This is a GitHub-first repo. package.json provides local scripts, package metadata, and packaging checks; npm publication is optional and not required for project-local installation.
npm run audit:privacy
npm run secret:scan
npm run syntax:check
npm run validate
npm run agent:check
npm test
npm run check
npm run smoke:install
npm run release:check
npm run package:list
npm run memory:validate -- --target /path/to/operational-folder
npm run workflow:context-budget -- --target /path/to/operational-folder
node scripts/doctor.mjs --help
node scripts/install.mjs --helpnpm run check is the expected CI path. It runs the privacy audit, dependency-free secret scan, syntax check, workflow validation, deterministic agent compliance, and tests. npm run release:check adds the install smoke test, package audit, and release-readiness gate.
See also:
- Quickstart
- Codex-Assisted Install
- Using The Kit
- Troubleshooting
- FAQ
- Compatibility
- CLI Reference
- Included Agents And Skills
- Workflow Map
- Provider-Neutral Boundary
- Memory Cache
- Context Folder
- Semantic Memory
- Self-Improvement Tools
- OpenAI API Policy
- v1.0 Readiness
- Release Guide
- Release Notes Template
- Roadmap
- Architecture
- Artifact Schemas
- Creative Prompting Workflow
- Human Voice And Copy Delivery
- Example Authoring
- Workflow Stages
- Onboarding
- Customization
- Team Configuration
- Text-Bearing Image Policy
- Hipson Integration
- HyperFrames
- Recurring Workflow Review
- Workflow Self-Improvement
- Migration Guide
- Agent Roster
- Repository Settings
- Examples Index
- End-To-End Creative Workflow Example
- Minimal Workflow Example
- Static Campaign Example
- Ecommerce Product Visual Example
- Video Storyboard Example
- Storyboard Board Example
- HyperFrames Video Example
- Image Prompt Pack Example
- Document Workflow Example
- Hipson Adapter Packets Example
- QA And Delivery Review Example
- No External Execution Mode Example
- Contributing
- Security
- Support
- Maintainers
- Code of Conduct
This kit ships the routing and contract layer for creative work and was created by FrameCore Works. To support its development, visit https://buycoffee.to/framecoreworks.